diff --git a/common/c-api/consumerstatetable.cpp b/common/c-api/consumerstatetable.cpp
index 9765ceec3..426055da1 100644
--- a/common/c-api/consumerstatetable.cpp
+++ b/common/c-api/consumerstatetable.cpp
@@ -13,33 +13,37 @@ using namespace swss;
 using namespace std;
 using boost::numeric_cast;
 
-SWSSConsumerStateTable SWSSConsumerStateTable_new(SWSSDBConnector db, const char *tableName,
-                                                  const int32_t *p_popBatchSize,
-                                                  const int32_t *p_pri) {
-    int popBatchSize = p_popBatchSize ? numeric_cast<int>(*p_popBatchSize)
-                                      : TableConsumable::DEFAULT_POP_BATCH_SIZE;
-    int pri = p_pri ? numeric_cast<int>(*p_pri) : 0;
-    SWSSTry(return (SWSSConsumerStateTable) new ConsumerStateTable(
-        (DBConnector *)db, string(tableName), popBatchSize, pri));
+SWSSResult SWSSConsumerStateTable_new(SWSSDBConnector db, const char *tableName,
+                                      const int32_t *p_popBatchSize, const int32_t *p_pri,
+                                      SWSSConsumerStateTable *outTbl) {
+    SWSSTry({
+        int popBatchSize = p_popBatchSize ? numeric_cast<int>(*p_popBatchSize)
+                                          : TableConsumable::DEFAULT_POP_BATCH_SIZE;
+        int pri = p_pri ? numeric_cast<int>(*p_pri) : 0;
+        *outTbl = (SWSSConsumerStateTable) new ConsumerStateTable(
+            (DBConnector *)db, string(tableName), popBatchSize, pri);
+    });
 }
 
-void SWSSConsumerStateTable_free(SWSSConsumerStateTable tbl) {
+SWSSResult SWSSConsumerStateTable_free(SWSSConsumerStateTable tbl) {
     SWSSTry(delete (ConsumerStateTable *)tbl);
 }
 
-SWSSKeyOpFieldValuesArray SWSSConsumerStateTable_pops(SWSSConsumerStateTable tbl) {
+SWSSResult SWSSConsumerStateTable_pops(SWSSConsumerStateTable tbl,
+                                       SWSSKeyOpFieldValuesArray *outArr) {
     SWSSTry({
         deque<KeyOpFieldsValuesTuple> vkco;
         ((ConsumerStateTable *)tbl)->pops(vkco);
-        return makeKeyOpFieldValuesArray(vkco);
+        *outArr = makeKeyOpFieldValuesArray(vkco);
     });
 }
 
-uint32_t SWSSConsumerStateTable_getFd(SWSSConsumerStateTable tbl) {
-    SWSSTry(return numeric_cast<uint32_t>(((ConsumerStateTable *)tbl)->getFd()));
+SWSSResult SWSSConsumerStateTable_getFd(SWSSConsumerStateTable tbl, uint32_t *outFd) {
+    SWSSTry(*outFd = numeric_cast<uint32_t>(((ConsumerStateTable *)tbl)->getFd()));
 }
 
-SWSSSelectResult SWSSConsumerStateTable_readData(SWSSConsumerStateTable tbl, uint32_t timeout_ms,
-                                                 uint8_t interrupt_on_signal) {
-    SWSSTry(return selectOne((ConsumerStateTable *)tbl, timeout_ms, interrupt_on_signal));
+SWSSResult SWSSConsumerStateTable_readData(SWSSConsumerStateTable tbl, uint32_t timeout_ms,
+                                           uint8_t interrupt_on_signal,
+                                           SWSSSelectResult *outResult) {
+    SWSSTry(*outResult = selectOne((ConsumerStateTable *)tbl, timeout_ms, interrupt_on_signal));
 }
diff --git a/common/c-api/consumerstatetable.h b/common/c-api/consumerstatetable.h
index 468fb644b..43ed4cde4 100644
--- a/common/c-api/consumerstatetable.h
+++ b/common/c-api/consumerstatetable.h
@@ -2,6 +2,7 @@
 #define SWSS_COMMON_C_API_CONSUMERSTATETABLE_H
 
 #include "dbconnector.h"
+#include "result.h"
 #include "util.h"
 
 #ifdef __cplusplus
@@ -12,25 +13,25 @@ extern "C" {
 
 typedef struct SWSSConsumerStateTableOpaque *SWSSConsumerStateTable;
 
-// Pass NULL for popBatchSize and/or pri to use the default values
-SWSSConsumerStateTable SWSSConsumerStateTable_new(SWSSDBConnector db, const char *tableName,
-                                                  const int32_t *popBatchSize, const int32_t *pri);
+SWSSResult SWSSConsumerStateTable_new(SWSSDBConnector db, const char *tableName,
+                                      const int32_t *popBatchSize, const int32_t *pri,
+                                      SWSSConsumerStateTable *outTbl);
 
-void SWSSConsumerStateTable_free(SWSSConsumerStateTable tbl);
+SWSSResult SWSSConsumerStateTable_free(SWSSConsumerStateTable tbl);
 
 // Result array and all of its members must be freed using free()
-SWSSKeyOpFieldValuesArray SWSSConsumerStateTable_pops(SWSSConsumerStateTable tbl);
+SWSSResult SWSSConsumerStateTable_pops(SWSSConsumerStateTable tbl, SWSSKeyOpFieldValuesArray *outArr);
 
-// Return the underlying fd for polling/selecting on.
-// Callers must NOT read/write on fd, it may only be used for epoll or similar.
+// Outputs the underlying fd for polling/selecting on.
+// Callers must NOT read/write on the fd, it may only be used for epoll or similar.
 // After the fd becomes readable, SWSSConsumerStateTable_readData must be used to
 // reset the fd and read data into internal data structures.
-uint32_t SWSSConsumerStateTable_getFd(SWSSConsumerStateTable tbl);
+SWSSResult SWSSConsumerStateTable_getFd(SWSSConsumerStateTable tbl, uint32_t *outFd);
 
 // Block until data is available to read or until a timeout elapses.
 // A timeout of 0 means the call will return immediately.
-SWSSSelectResult SWSSConsumerStateTable_readData(SWSSConsumerStateTable tbl, uint32_t timeout_ms,
-                                                 uint8_t interrupt_on_signal);
+SWSSResult SWSSConsumerStateTable_readData(SWSSConsumerStateTable tbl, uint32_t timeout_ms,
+                                           uint8_t interrupt_on_signal, SWSSSelectResult *outResult);
 
 #ifdef __cplusplus
 }
diff --git a/common/c-api/producerstatetable.cpp b/common/c-api/producerstatetable.cpp
index 276d7c680..c9cc34463 100644
--- a/common/c-api/producerstatetable.cpp
+++ b/common/c-api/producerstatetable.cpp
@@ -10,44 +10,45 @@
 using namespace swss;
 using namespace std;
 
-SWSSProducerStateTable SWSSProducerStateTable_new(SWSSDBConnector db, const char *tableName) {
-    SWSSTry(return (SWSSProducerStateTable) new ProducerStateTable((DBConnector *)db,
-                                                                   string(tableName)));
+SWSSResult SWSSProducerStateTable_new(SWSSDBConnector db, const char *tableName,
+                                      SWSSProducerStateTable *outTbl) {
+    SWSSTry(*outTbl = (SWSSProducerStateTable) new ProducerStateTable((DBConnector *)db,
+                                                                      string(tableName)));
 }
 
-void SWSSProducerStateTable_free(SWSSProducerStateTable tbl) {
+SWSSResult SWSSProducerStateTable_free(SWSSProducerStateTable tbl) {
     SWSSTry(delete ((ProducerStateTable *)tbl));
 }
 
-void SWSSProducerStateTable_setBuffered(SWSSProducerStateTable tbl, uint8_t buffered) {
-    SWSSTry(((ProducerStateTable *)tbl)->setBuffered((bool)buffered))
+SWSSResult SWSSProducerStateTable_setBuffered(SWSSProducerStateTable tbl, uint8_t buffered) {
+    SWSSTry(((ProducerStateTable *)tbl)->setBuffered((bool)buffered));
 }
 
-void SWSSProducerStateTable_set(SWSSProducerStateTable tbl, const char *key,
-                                SWSSFieldValueArray values) {
+SWSSResult SWSSProducerStateTable_set(SWSSProducerStateTable tbl, const char *key,
+                                      SWSSFieldValueArray values) {
     SWSSTry(((ProducerStateTable *)tbl)->set(string(key), takeFieldValueArray(std::move(values))));
 }
 
-void SWSSProducerStateTable_del(SWSSProducerStateTable tbl, const char *key) {
+SWSSResult SWSSProducerStateTable_del(SWSSProducerStateTable tbl, const char *key) {
     SWSSTry(((ProducerStateTable *)tbl)->del(string(key)));
 }
 
-void SWSSProducerStateTable_flush(SWSSProducerStateTable tbl) {
+SWSSResult SWSSProducerStateTable_flush(SWSSProducerStateTable tbl) {
     SWSSTry(((ProducerStateTable *)tbl)->flush());
 }
 
-int64_t SWSSProducerStateTable_count(SWSSProducerStateTable tbl) {
-    SWSSTry(return ((ProducerStateTable *)tbl)->count());
+SWSSResult SWSSProducerStateTable_count(SWSSProducerStateTable tbl, int64_t *outCount) {
+    SWSSTry(*outCount = ((ProducerStateTable *)tbl)->count());
 }
 
-void SWSSProducerStateTable_clear(SWSSProducerStateTable tbl) {
+SWSSResult SWSSProducerStateTable_clear(SWSSProducerStateTable tbl) {
     SWSSTry(((ProducerStateTable *)tbl)->clear());
 }
 
-void SWSSProducerStateTable_create_temp_view(SWSSProducerStateTable tbl) {
+SWSSResult SWSSProducerStateTable_create_temp_view(SWSSProducerStateTable tbl) {
     SWSSTry(((ProducerStateTable *)tbl)->create_temp_view());
 }
 
-void SWSSProducerStateTable_apply_temp_view(SWSSProducerStateTable tbl) {
+SWSSResult SWSSProducerStateTable_apply_temp_view(SWSSProducerStateTable tbl) {
     SWSSTry(((ProducerStateTable *)tbl)->apply_temp_view());
 }
diff --git a/common/c-api/producerstatetable.h b/common/c-api/producerstatetable.h
index 1acb9af37..463aeaaec 100644
--- a/common/c-api/producerstatetable.h
+++ b/common/c-api/producerstatetable.h
@@ -2,6 +2,7 @@
 #define SWSS_COMMON_C_API_PRODUCERSTATETABLE_H
 
 #include "dbconnector.h"
+#include "result.h"
 #include "util.h"
 
 #ifdef __cplusplus
@@ -11,26 +12,27 @@ extern "C" {
 #include <stdint.h>
 
 typedef struct SWSSProducerStateTableOpaque *SWSSProducerStateTable;
+SWSSResult SWSSProducerStateTable_new(SWSSDBConnector db, const char *tableName,
+                                      SWSSProducerStateTable *outTbl);
 
-SWSSProducerStateTable SWSSProducerStateTable_new(SWSSDBConnector db, const char *tableName);
+SWSSResult SWSSProducerStateTable_free(SWSSProducerStateTable tbl);
 
-void SWSSProducerStateTable_free(SWSSProducerStateTable tbl);
+SWSSResult SWSSProducerStateTable_setBuffered(SWSSProducerStateTable tbl, uint8_t buffered);
 
-void SWSSProducerStateTable_setBuffered(SWSSProducerStateTable tbl, uint8_t buffered);
+SWSSResult SWSSProducerStateTable_set(SWSSProducerStateTable tbl, const char *key,
+                                      SWSSFieldValueArray values);
 
-void SWSSProducerStateTable_set(SWSSProducerStateTable tbl, const char *key, SWSSFieldValueArray values);
+SWSSResult SWSSProducerStateTable_del(SWSSProducerStateTable tbl, const char *key);
 
-void SWSSProducerStateTable_del(SWSSProducerStateTable tbl, const char *key);
+SWSSResult SWSSProducerStateTable_flush(SWSSProducerStateTable tbl);
 
-void SWSSProducerStateTable_flush(SWSSProducerStateTable tbl);
+SWSSResult SWSSProducerStateTable_count(SWSSProducerStateTable tbl, int64_t *outCount);
 
-int64_t SWSSProducerStateTable_count(SWSSProducerStateTable tbl);
+SWSSResult SWSSProducerStateTable_clear(SWSSProducerStateTable tbl);
 
-void SWSSProducerStateTable_clear(SWSSProducerStateTable tbl);
+SWSSResult SWSSProducerStateTable_create_temp_view(SWSSProducerStateTable tbl);
 
-void SWSSProducerStateTable_create_temp_view(SWSSProducerStateTable tbl);
-
-void SWSSProducerStateTable_apply_temp_view(SWSSProducerStateTable tbl);
+SWSSResult SWSSProducerStateTable_apply_temp_view(SWSSProducerStateTable tbl);
 
 #ifdef __cplusplus
 }
diff --git a/common/c-api/subscriberstatetable.cpp b/common/c-api/subscriberstatetable.cpp
index 4d3a04953..3e1deb8ec 100644
--- a/common/c-api/subscriberstatetable.cpp
+++ b/common/c-api/subscriberstatetable.cpp
@@ -14,34 +14,37 @@ using namespace swss;
 using namespace std;
 using boost::numeric_cast;
 
-SWSSSubscriberStateTable SWSSSubscriberStateTable_new(SWSSDBConnector db, const char *tableName,
-                                                      const int32_t *p_popBatchSize,
-                                                      const int32_t *p_pri) {
-    int popBatchSize = p_popBatchSize ? numeric_cast<int>(*p_popBatchSize)
-                                      : TableConsumable::DEFAULT_POP_BATCH_SIZE;
-    int pri = p_pri ? numeric_cast<int>(*p_pri) : 0;
-    SWSSTry(return (SWSSSubscriberStateTable) new SubscriberStateTable(
-        (DBConnector *)db, string(tableName), popBatchSize, pri));
+SWSSResult SWSSSubscriberStateTable_new(SWSSDBConnector db, const char *tableName,
+                                        const int32_t *p_popBatchSize, const int32_t *p_pri,
+                                        SWSSSubscriberStateTable *outTbl) {
+    SWSSTry({
+        int popBatchSize = p_popBatchSize ? numeric_cast<int>(*p_popBatchSize)
+                                          : TableConsumable::DEFAULT_POP_BATCH_SIZE;
+        int pri = p_pri ? numeric_cast<int>(*p_pri) : 0;
+        *outTbl = (SWSSSubscriberStateTable) new SubscriberStateTable(
+            (DBConnector *)db, string(tableName), popBatchSize, pri);
+    });
 }
 
-void SWSSSubscriberStateTable_free(SWSSSubscriberStateTable tbl) {
-    delete (SubscriberStateTable *)tbl;
+SWSSResult SWSSSubscriberStateTable_free(SWSSSubscriberStateTable tbl) {
+    SWSSTry(delete (SubscriberStateTable *)tbl);
 }
 
-SWSSKeyOpFieldValuesArray SWSSSubscriberStateTable_pops(SWSSSubscriberStateTable tbl) {
+SWSSResult SWSSSubscriberStateTable_pops(SWSSSubscriberStateTable tbl,
+                                         SWSSKeyOpFieldValuesArray *outArr) {
     SWSSTry({
         deque<KeyOpFieldsValuesTuple> vkco;
         ((SubscriberStateTable *)tbl)->pops(vkco);
-        return makeKeyOpFieldValuesArray(vkco);
+        *outArr = makeKeyOpFieldValuesArray(vkco);
     });
 }
 
-uint32_t SWSSSubscriberStateTable_getFd(SWSSSubscriberStateTable tbl) {
-    SWSSTry(return numeric_cast<uint32_t>(((SubscriberStateTable *)tbl)->getFd()));
+SWSSResult SWSSSubscriberStateTable_getFd(SWSSSubscriberStateTable tbl, uint32_t *outFd) {
+    SWSSTry(*outFd = numeric_cast<uint32_t>(((SubscriberStateTable *)tbl)->getFd()));
 }
 
-SWSSSelectResult SWSSSubscriberStateTable_readData(SWSSSubscriberStateTable tbl,
-                                                   uint32_t timeout_ms,
-                                                   uint8_t interrupt_on_signal) {
-    SWSSTry(return selectOne((SubscriberStateTable *)tbl, timeout_ms, interrupt_on_signal));
+SWSSResult SWSSSubscriberStateTable_readData(SWSSSubscriberStateTable tbl, uint32_t timeout_ms,
+                                             uint8_t interrupt_on_signal,
+                                             SWSSSelectResult *outResult) {
+    SWSSTry(*outResult = selectOne((SubscriberStateTable *)tbl, timeout_ms, interrupt_on_signal));
 }
diff --git a/common/c-api/subscriberstatetable.h b/common/c-api/subscriberstatetable.h
index ed0924c81..5f7444063 100644
--- a/common/c-api/subscriberstatetable.h
+++ b/common/c-api/subscriberstatetable.h
@@ -2,6 +2,7 @@
 #define SWSS_COMMON_C_API_SUBSCRIBERSTATETABLE_H
 
 #include "dbconnector.h"
+#include "result.h"
 #include "util.h"
 
 #ifdef __cplusplus
@@ -12,27 +13,28 @@ extern "C" {
 
 typedef struct SWSSSubscriberStateTableOpaque *SWSSSubscriberStateTable;
 
-// Pass NULL for popBatchSize and/or pri to use the default values
-SWSSSubscriberStateTable SWSSSubscriberStateTable_new(SWSSDBConnector db, const char *tableName,
-                                                      const int32_t *popBatchSize,
-                                                      const int32_t *pri);
+SWSSResult SWSSSubscriberStateTable_new(SWSSDBConnector db, const char *tableName,
+                                        const int32_t *popBatchSize, const int32_t *pri,
+                                        SWSSSubscriberStateTable *outTbl);
 
-void SWSSSubscriberStateTable_free(SWSSSubscriberStateTable tbl);
+// Frees the SubscriberStateTable
+SWSSResult SWSSSubscriberStateTable_free(SWSSSubscriberStateTable tbl);
 
 // Result array and all of its members must be freed using free()
-SWSSKeyOpFieldValuesArray SWSSSubscriberStateTable_pops(SWSSSubscriberStateTable tbl);
+SWSSResult SWSSSubscriberStateTable_pops(SWSSSubscriberStateTable tbl,
+                                         SWSSKeyOpFieldValuesArray *outArr);
 
-// Return the underlying fd for polling/selecting on.
-// Callers must NOT read/write on fd, it may only be used for epoll or similar.
+// Outputs the underlying fd for polling/selecting on.
+// Callers must NOT read/write on the fd, it may only be used for epoll or similar.
 // After the fd becomes readable, SWSSSubscriberStateTable_readData must be used to
 // reset the fd and read data into internal data structures.
-uint32_t SWSSSubscriberStateTable_getFd(SWSSSubscriberStateTable tbl);
+SWSSResult SWSSSubscriberStateTable_getFd(SWSSSubscriberStateTable tbl, uint32_t *outFd);
 
 // Block until data is available to read or until a timeout elapses.
 // A timeout of 0 means the call will return immediately.
-SWSSSelectResult SWSSSubscriberStateTable_readData(SWSSSubscriberStateTable tbl,
-                                                   uint32_t timeout_ms,
-                                                   uint8_t interrupt_on_sugnal);
+SWSSResult SWSSSubscriberStateTable_readData(SWSSSubscriberStateTable tbl, uint32_t timeout_ms,
+                                             uint8_t interrupt_on_signal,
+                                             SWSSSelectResult *outResult);
 
 #ifdef __cplusplus
 }
diff --git a/common/c-api/table.cpp b/common/c-api/table.cpp
index af08cbaa8..d3e88c9cb 100644
--- a/common/c-api/table.cpp
+++ b/common/c-api/table.cpp
@@ -9,63 +9,65 @@
 using namespace swss;
 using namespace std;
 
-SWSSTable SWSSTable_new(SWSSDBConnector db, const char *tableName) {
-    SWSSTry(return (SWSSTable) new Table((DBConnector *)db, string(tableName)));
+SWSSResult SWSSTable_new(SWSSDBConnector db, const char *tableName, SWSSTable *outTbl) {
+    SWSSTry(*outTbl = (SWSSTable) new Table((DBConnector *)db, string(tableName)));
 }
 
-void SWSSTable_free(SWSSTable tbl) {
+SWSSResult SWSSTable_free(SWSSTable tbl) {
     SWSSTry(delete (Table *)tbl);
 }
 
-int8_t SWSSTable_get(SWSSTable tbl, const char *key, SWSSFieldValueArray *outValues) {
+SWSSResult SWSSTable_get(SWSSTable tbl, const char *key, SWSSFieldValueArray *outValues,
+                         int8_t *outExists) {
     SWSSTry({
         vector<FieldValueTuple> fvs;
         bool exists = ((Table *)tbl)->get(string(key), fvs);
         if (exists) {
             *outValues = makeFieldValueArray(fvs);
-            return 1;
+            *outExists = 1;
         } else {
-            return 0;
+            *outExists = 0;
         }
     });
 }
 
-int8_t SWSSTable_hget(SWSSTable tbl, const char *key, const char *field, SWSSString *outValue) {
+SWSSResult SWSSTable_hget(SWSSTable tbl, const char *key, const char *field, SWSSString *outValue,
+                          int8_t *outExists) {
     SWSSTry({
         string s;
         bool exists = ((Table *)tbl)->hget(string(key), string(field), s);
         if (exists) {
             *outValue = makeString(move(s));
-            return 1;
+            *outExists = 1;
         } else {
-            return 0;
+            *outExists = 0;
         }
     });
 }
 
-void SWSSTable_set(SWSSTable tbl, const char *key, SWSSFieldValueArray values) {
+SWSSResult SWSSTable_set(SWSSTable tbl, const char *key, SWSSFieldValueArray values) {
     SWSSTry({
         vector<FieldValueTuple> fvs = takeFieldValueArray(values);
         ((Table *)tbl)->set(string(key), fvs);
     });
 }
 
-void SWSSTable_hset(SWSSTable tbl, const char *key, const char *field, SWSSStrRef value) {
-    SWSSTry({ ((Table *)tbl)->hset(string(key), string(field), takeStrRef(value)); });
+SWSSResult SWSSTable_hset(SWSSTable tbl, const char *key, const char *field, SWSSStrRef value) {
+    SWSSTry(((Table *)tbl)->hset(string(key), string(field), takeStrRef(value)));
 }
 
-void SWSSTable_del(SWSSTable tbl, const char *key) {
-    SWSSTry({ ((Table *)tbl)->del(string(key)); });
+SWSSResult SWSSTable_del(SWSSTable tbl, const char *key) {
+    SWSSTry(((Table *)tbl)->del(string(key)));
 }
 
-void SWSSTable_hdel(SWSSTable tbl, const char *key, const char *field) {
-    SWSSTry({ ((Table *)tbl)->hdel(string(key), string(field)); });
+SWSSResult SWSSTable_hdel(SWSSTable tbl, const char *key, const char *field) {
+    SWSSTry(((Table *)tbl)->hdel(string(key), string(field)));
 }
 
-SWSSStringArray SWSSTable_getKeys(SWSSTable tbl) {
+SWSSResult SWSSTable_getKeys(SWSSTable tbl, SWSSStringArray *outKeys) {
     SWSSTry({
         vector<string> keys;
         ((Table *)tbl)->getKeys(keys);
-        return makeStringArray(move(keys));
-    })
+        *outKeys = makeStringArray(move(keys));
+    });
 }
diff --git a/common/c-api/table.h b/common/c-api/table.h
index 0d06e1e7d..087bec815 100644
--- a/common/c-api/table.h
+++ b/common/c-api/table.h
@@ -2,6 +2,7 @@
 #define SWSS_COMMON_C_API_TABLE_H
 
 #include "dbconnector.h"
+#include "result.h"
 #include "util.h"
 
 #ifdef __cplusplus
@@ -12,27 +13,29 @@ extern "C" {
 
 typedef struct SWSSTableOpaque *SWSSTable;
 
-SWSSTable SWSSTable_new(SWSSDBConnector db, const char *tableName);
+SWSSResult SWSSTable_new(SWSSDBConnector db, const char *tableName, SWSSTable *outTbl);
 
-void SWSSTable_free(SWSSTable tbl);
+SWSSResult SWSSTable_free(SWSSTable tbl);
 
-// If the key exists, populates outValues with the table's values and returns 1. 
-// If the key doesn't exist, returns 0.
-int8_t SWSSTable_get(SWSSTable tbl, const char *key, SWSSFieldValueArray *outValues);
+// If the key exists, populates outValues with the table's values and outputs 1.
+// If the key doesn't exist, outputs 0 and does not touch outValues.
+SWSSResult SWSSTable_get(SWSSTable tbl, const char *key, SWSSFieldValueArray *outValues,
+                         int8_t *outExists);
 
-// If the key and field exist, populates outValue with the field's value and returns 1. 
-// If the key doesn't exist, returns 0.
-int8_t SWSSTable_hget(SWSSTable tbl, const char *key, const char *field, SWSSString *outValue);
+// If the key and field exist, populates outValue with the field's value and outputs 1.
+// If the key doesn't exist, outputs 0 and does not touch outValue.
+SWSSResult SWSSTable_hget(SWSSTable tbl, const char *key, const char *field, SWSSString *outValue,
+                          int8_t *outExists);
 
-void SWSSTable_set(SWSSTable tbl, const char *key, SWSSFieldValueArray values);
+SWSSResult SWSSTable_set(SWSSTable tbl, const char *key, SWSSFieldValueArray values);
 
-void SWSSTable_hset(SWSSTable tbl, const char *key, const char *field, SWSSStrRef value);
+SWSSResult SWSSTable_hset(SWSSTable tbl, const char *key, const char *field, SWSSStrRef value);
 
-void SWSSTable_del(SWSSTable tbl, const char *key);
+SWSSResult SWSSTable_del(SWSSTable tbl, const char *key);
 
-void SWSSTable_hdel(SWSSTable tbl, const char *key, const char *field);
+SWSSResult SWSSTable_hdel(SWSSTable tbl, const char *key, const char *field);
 
-SWSSStringArray SWSSTable_getKeys(SWSSTable tbl);
+SWSSResult SWSSTable_getKeys(SWSSTable tbl, SWSSStringArray *outKeys);
 
 #ifdef __cplusplus
 }
diff --git a/common/c-api/util.cpp b/common/c-api/util.cpp
index 26cc1b0f4..bc173420c 100644
--- a/common/c-api/util.cpp
+++ b/common/c-api/util.cpp
@@ -2,36 +2,34 @@
 
 using namespace swss;
 
-bool swss::cApiTestingDisableAbort = false;
-
 SWSSString SWSSString_new(const char *data, uint64_t length) {
-    SWSSTry(return makeString(std::string(data, numeric_cast<std::string::size_type>(length))));
+    return makeString(std::string(data, numeric_cast<std::string::size_type>(length)));
 }
 
 SWSSString SWSSString_new_c_str(const char *c_str) {
-    SWSSTry(return makeString(std::string(c_str)));
+    return makeString(std::string(c_str));
 }
 
 const char *SWSSStrRef_c_str(SWSSStrRef s) {
-    SWSSTry(return ((std::string *)s)->c_str());
+    return ((std::string *)s)->c_str();
 }
 
 uint64_t SWSSStrRef_length(SWSSStrRef s) {
-    SWSSTry(return ((std::string *)s)->length());
+    return ((std::string *)s)->length();
 }
 
 void SWSSString_free(SWSSString s) {
-    SWSSTry(delete (std::string *)s);
+    delete (std::string *)s;
 }
 
 void SWSSFieldValueArray_free(SWSSFieldValueArray arr) {
-    SWSSTry(delete[] arr.data);
+    delete[] arr.data;
 }
 
 void SWSSKeyOpFieldValuesArray_free(SWSSKeyOpFieldValuesArray kfvs) {
-    SWSSTry(delete[] kfvs.data);
+    delete[] kfvs.data;
 }
 
 void SWSSStringArray_free(SWSSStringArray arr) {
-    SWSSTry(delete[] arr.data);
+    delete[] arr.data;
 }
diff --git a/common/c-api/util.h b/common/c-api/util.h
index aa0d66fbe..8ff3aa121 100644
--- a/common/c-api/util.h
+++ b/common/c-api/util.h
@@ -121,40 +121,20 @@ void SWSSStringArray_free(SWSSStringArray arr);
 
 using boost::numeric_cast;
 
-namespace swss {
-
-extern bool cApiTestingDisableAbort;
-
-// In the catch block, we must abort because passing an exception across an ffi boundary is
-// undefined behavior. It was also decided that no exceptions in swss-common are recoverable, so
-// there is no reason to convert exceptions into a returnable type.
-#define SWSSTry(...)                                                                               \
-    if (swss::cApiTestingDisableAbort) {                                                           \
-        { __VA_ARGS__; }                                                                           \
-    } else {                                                                                       \
-        try {                                                                                      \
-            { __VA_ARGS__; }                                                                       \
-        } catch (std::exception & e) {                                                             \
-            std::cerr << "Aborting due to exception: " << e.what() << std::endl;                   \
-            SWSS_LOG_ERROR("Aborting due to exception: %s", e.what());                             \
-            std::abort();                                                                          \
-        }                                                                                          \
-    }
-
 static inline SWSSSelectResult selectOne(swss::Selectable *s, uint32_t timeout_ms,
                                          uint8_t interrupt_on_signal) {
-    Select select;
-    Selectable *sOut;
+    swss::Select select;
+    swss::Selectable *sOut;
     select.addSelectable(s);
     int ret = select.select(&sOut, numeric_cast<int>(timeout_ms), interrupt_on_signal);
     switch (ret) {
-    case Select::OBJECT:
+    case swss::Select::OBJECT:
         return SWSSSelectResult_DATA;
-    case Select::ERROR:
+    case swss::Select::ERROR:
         throw std::system_error(errno, std::generic_category());
-    case Select::TIMEOUT:
+    case swss::Select::TIMEOUT:
         return SWSSSelectResult_TIMEOUT;
-    case Select::SIGNALINT:
+    case swss::Select::SIGNALINT:
         return SWSSSelectResult_SIGNAL;
     default:
         SWSS_LOG_THROW("impossible: unhandled Select::select() return value: %d", ret);
@@ -286,7 +266,5 @@ takeKeyOpFieldValuesArray(SWSSKeyOpFieldValuesArray in) {
     return out;
 }
 
-} // namespace swss
-
 #endif
 #endif
diff --git a/common/c-api/zmqclient.cpp b/common/c-api/zmqclient.cpp
index fa1d59ca2..9b0ef971a 100644
--- a/common/c-api/zmqclient.cpp
+++ b/common/c-api/zmqclient.cpp
@@ -6,25 +6,24 @@
 using namespace swss;
 using namespace std;
 
-SWSSZmqClient SWSSZmqClient_new(const char *endpoint) {
-    SWSSTry(return (SWSSZmqClient) new ZmqClient(endpoint));
+SWSSResult SWSSZmqClient_new(const char *endpoint, SWSSZmqClient *outClient) {
+    SWSSTry(*outClient = (SWSSZmqClient) new ZmqClient(endpoint));
 }
 
-void SWSSZmqClient_free(SWSSZmqClient zmqc) {
+SWSSResult SWSSZmqClient_free(SWSSZmqClient zmqc) {
     SWSSTry(delete (ZmqClient *)zmqc);
 }
 
-// Returns 0 for false, 1 for true
-int8_t SWSSZmqClient_isConnected(SWSSZmqClient zmqc) {
-    SWSSTry(return ((ZmqClient *)zmqc)->isConnected() ? 1 : 0);
+SWSSResult SWSSZmqClient_isConnected(SWSSZmqClient zmqc, int8_t *outIsConnected) {
+    SWSSTry(*outIsConnected = ((ZmqClient *)zmqc)->isConnected() ? 1 : 0);
 }
 
-void SWSSZmqClient_connect(SWSSZmqClient zmqc) {
+SWSSResult SWSSZmqClient_connect(SWSSZmqClient zmqc) {
     SWSSTry(((ZmqClient *)zmqc)->connect());
 }
 
-void SWSSZmqClient_sendMsg(SWSSZmqClient zmqc, const char *dbName, const char *tableName,
-                           SWSSKeyOpFieldValuesArray arr) {
+SWSSResult SWSSZmqClient_sendMsg(SWSSZmqClient zmqc, const char *dbName, const char *tableName,
+                                 SWSSKeyOpFieldValuesArray arr) {
     SWSSTry({
         vector<KeyOpFieldsValuesTuple> kcos = takeKeyOpFieldValuesArray(arr);
         ((ZmqClient *)zmqc)
diff --git a/common/c-api/zmqclient.h b/common/c-api/zmqclient.h
index da832ab30..d846f598d 100644
--- a/common/c-api/zmqclient.h
+++ b/common/c-api/zmqclient.h
@@ -1,6 +1,7 @@
 #ifndef SWSS_COMMON_C_API_ZMQCLIENT_H
 #define SWSS_COMMON_C_API_ZMQCLIENT_H
 
+#include "result.h"
 #include "util.h"
 
 #ifdef __cplusplus
@@ -11,17 +12,17 @@ extern "C" {
 
 typedef struct SWSSZmqClientOpaque *SWSSZmqClient;
 
-SWSSZmqClient SWSSZmqClient_new(const char *endpoint);
+SWSSResult SWSSZmqClient_new(const char *endpoint, SWSSZmqClient *outZmqc);
 
-void SWSSZmqClient_free(SWSSZmqClient zmqc);
+SWSSResult SWSSZmqClient_free(SWSSZmqClient zmqc);
 
-// Returns 0 for false, 1 for true
-int8_t SWSSZmqClient_isConnected(SWSSZmqClient zmqc);
+// Outputs 0 for false, 1 for true
+SWSSResult SWSSZmqClient_isConnected(SWSSZmqClient zmqc, int8_t *outIsConnected);
 
-void SWSSZmqClient_connect(SWSSZmqClient zmqc);
+SWSSResult SWSSZmqClient_connect(SWSSZmqClient zmqc);
 
-void SWSSZmqClient_sendMsg(SWSSZmqClient zmqc, const char *dbName, const char *tableName,
-                           SWSSKeyOpFieldValuesArray kcos);
+SWSSResult SWSSZmqClient_sendMsg(SWSSZmqClient zmqc, const char *dbName, const char *tableName,
+                                 SWSSKeyOpFieldValuesArray kcos);
 
 #ifdef __cplusplus
 }
diff --git a/common/c-api/zmqconsumerstatetable.cpp b/common/c-api/zmqconsumerstatetable.cpp
index ed416488e..59ed7dde4 100644
--- a/common/c-api/zmqconsumerstatetable.cpp
+++ b/common/c-api/zmqconsumerstatetable.cpp
@@ -1,4 +1,3 @@
-#include <boost/numeric/conversion/cast.hpp>
 #include "../zmqconsumerstatetable.h"
 #include "../table.h"
 #include "util.h"
@@ -11,41 +10,43 @@ using namespace std;
 using boost::numeric_cast;
 
 // Pass NULL for popBatchSize and/or pri to use the default values
-SWSSZmqConsumerStateTable SWSSZmqConsumerStateTable_new(SWSSDBConnector db, const char *tableName,
-                                                        SWSSZmqServer zmqs,
-                                                        const int32_t *p_popBatchSize,
-                                                        const int32_t *p_pri) {
-
-    int popBatchSize = p_popBatchSize ? numeric_cast<int>(*p_popBatchSize)
-                                      : TableConsumable::DEFAULT_POP_BATCH_SIZE;
-    int pri = p_pri ? numeric_cast<int>(*p_pri) : 0;
-    SWSSTry(return (SWSSZmqConsumerStateTable) new ZmqConsumerStateTable(
-        (DBConnector *)db, string(tableName), *(ZmqServer *)zmqs, popBatchSize, pri));
+SWSSResult SWSSZmqConsumerStateTable_new(SWSSDBConnector db, const char *tableName,
+                                         SWSSZmqServer zmqs, const int32_t *p_popBatchSize,
+                                         const int32_t *p_pri, SWSSZmqConsumerStateTable *outTbl) {
+    SWSSTry({
+        int popBatchSize = p_popBatchSize ? numeric_cast<int>(*p_popBatchSize)
+                                          : TableConsumable::DEFAULT_POP_BATCH_SIZE;
+        int pri = p_pri ? numeric_cast<int>(*p_pri) : 0;
+        *outTbl = (SWSSZmqConsumerStateTable) new ZmqConsumerStateTable(
+            (DBConnector *)db, string(tableName), *(ZmqServer *)zmqs, popBatchSize, pri);
+    });
 }
 
-void SWSSZmqConsumerStateTable_free(SWSSZmqConsumerStateTable tbl) {
+SWSSResult SWSSZmqConsumerStateTable_free(SWSSZmqConsumerStateTable tbl) {
     SWSSTry(delete (ZmqConsumerStateTable *)tbl);
 }
 
-SWSSKeyOpFieldValuesArray SWSSZmqConsumerStateTable_pops(SWSSZmqConsumerStateTable tbl) {
+SWSSResult SWSSZmqConsumerStateTable_pops(SWSSZmqConsumerStateTable tbl,
+                                          SWSSKeyOpFieldValuesArray *outArr) {
     SWSSTry({
         deque<KeyOpFieldsValuesTuple> vkco;
         ((ZmqConsumerStateTable *)tbl)->pops(vkco);
-        return makeKeyOpFieldValuesArray(vkco);
+        *outArr = makeKeyOpFieldValuesArray(vkco);
     });
 }
 
-uint32_t SWSSZmqConsumerStateTable_getFd(SWSSZmqConsumerStateTable tbl) {
-    SWSSTry(return numeric_cast<uint32_t>(((ZmqConsumerStateTable *)tbl)->getFd()));
+SWSSResult SWSSZmqConsumerStateTable_getFd(SWSSZmqConsumerStateTable tbl, uint32_t *outFd) {
+    SWSSTry(*outFd = numeric_cast<uint32_t>(((ZmqConsumerStateTable *)tbl)->getFd()));
 }
 
-SWSSSelectResult SWSSZmqConsumerStateTable_readData(SWSSZmqConsumerStateTable tbl,
-                                                    uint32_t timeout_ms,
-                                                    uint8_t interrupt_on_signal) {
-    SWSSTry(return selectOne((ZmqConsumerStateTable *)tbl, timeout_ms, interrupt_on_signal));
+SWSSResult SWSSZmqConsumerStateTable_readData(SWSSZmqConsumerStateTable tbl, uint32_t timeout_ms,
+                                              uint8_t interrupt_on_signal,
+                                              SWSSSelectResult *outResult) {
+    SWSSTry(*outResult = selectOne((ZmqConsumerStateTable *)tbl, timeout_ms, interrupt_on_signal));
 }
 
-const struct SWSSDBConnectorOpaque *
-SWSSZmqConsumerStateTable_getDbConnector(SWSSZmqConsumerStateTable tbl) {
-    SWSSTry(return (const SWSSDBConnectorOpaque *)((ZmqConsumerStateTable *)tbl)->getDbConnector());
+SWSSResult SWSSZmqConsumerStateTable_getDbConnector(SWSSZmqConsumerStateTable tbl,
+                                                    const struct SWSSDBConnectorOpaque **outDb) {
+    SWSSTry(*outDb =
+                (const SWSSDBConnectorOpaque *)((ZmqConsumerStateTable *)tbl)->getDbConnector());
 }
diff --git a/common/c-api/zmqconsumerstatetable.h b/common/c-api/zmqconsumerstatetable.h
index f5b934258..f781f6bc8 100644
--- a/common/c-api/zmqconsumerstatetable.h
+++ b/common/c-api/zmqconsumerstatetable.h
@@ -2,6 +2,7 @@
 #define SWSS_COMMON_C_API_ZMQCONSUMERSTATETABLE_H
 
 #include "dbconnector.h"
+#include "result.h"
 #include "util.h"
 #include "zmqserver.h"
 
@@ -13,31 +14,32 @@ extern "C" {
 
 typedef struct SWSSZmqConsumerStateTableOpaque *SWSSZmqConsumerStateTable;
 
-// Pass NULL for popBatchSize and/or pri to use the default values
-SWSSZmqConsumerStateTable SWSSZmqConsumerStateTable_new(SWSSDBConnector db, const char *tableName,
-                                                        SWSSZmqServer zmqs,
-                                                        const int32_t *popBatchSize,
-                                                        const int32_t *pri);
+SWSSResult SWSSZmqConsumerStateTable_new(SWSSDBConnector db, const char *tableName,
+                                         SWSSZmqServer zmqs, const int32_t *popBatchSize,
+                                         const int32_t *pri, SWSSZmqConsumerStateTable *outTbl);
 
-void SWSSZmqConsumerStateTable_free(SWSSZmqConsumerStateTable tbl);
+// Outputs NULL for popBatchSize and/or pri to use the default values
+SWSSResult SWSSZmqConsumerStateTable_free(SWSSZmqConsumerStateTable tbl);
 
 // Result array and all of its members must be freed using free()
-SWSSKeyOpFieldValuesArray SWSSZmqConsumerStateTable_pops(SWSSZmqConsumerStateTable tbl);
+SWSSResult SWSSZmqConsumerStateTable_pops(SWSSZmqConsumerStateTable tbl,
+                                          SWSSKeyOpFieldValuesArray *outArr);
 
-// Return the underlying fd for polling/selecting on.
+// Outputs the underlying fd for polling/selecting on.
 // Callers must NOT read/write on fd, it may only be used for epoll or similar.
 // After the fd becomes readable, SWSSZmqConsumerStateTable_readData must be used to
 // reset the fd and read data into internal data structures.
-uint32_t SWSSZmqConsumerStateTable_getFd(SWSSZmqConsumerStateTable tbl);
+SWSSResult SWSSZmqConsumerStateTable_getFd(SWSSZmqConsumerStateTable tbl, uint32_t *outFd);
 
 // Block until data is available to read or until a timeout elapses.
 // A timeout of 0 means the call will return immediately.
-SWSSSelectResult SWSSZmqConsumerStateTable_readData(SWSSZmqConsumerStateTable tbl,
-                                                    uint32_t timeout_ms,
-                                                    uint8_t interrupt_on_signal);
+SWSSResult SWSSZmqConsumerStateTable_readData(SWSSZmqConsumerStateTable tbl, uint32_t timeout_ms,
+                                              uint8_t interrupt_on_signal,
+                                              SWSSSelectResult *outResult);
 
-const struct SWSSDBConnectorOpaque *
-SWSSZmqConsumerStateTable_getDbConnector(SWSSZmqConsumerStateTable tbl);
+SWSSResult
+SWSSZmqConsumerStateTable_getDbConnector(SWSSZmqConsumerStateTable tbl,
+                                         const struct SWSSDBConnectorOpaque **outDbConnector);
 
 #ifdef __cplusplus
 }
diff --git a/common/c-api/zmqproducerstatetable.cpp b/common/c-api/zmqproducerstatetable.cpp
index e1c186806..b9192ee39 100644
--- a/common/c-api/zmqproducerstatetable.cpp
+++ b/common/c-api/zmqproducerstatetable.cpp
@@ -1,32 +1,34 @@
 #include <boost/numeric/conversion/cast.hpp>
 
-#include "zmqproducerstatetable.h"
 #include "../zmqproducerstatetable.h"
+#include "zmqproducerstatetable.h"
 
 using namespace std;
 using namespace swss;
 using boost::numeric_cast;
 
-SWSSZmqProducerStateTable SWSSZmqProducerStateTable_new(SWSSDBConnector db, const char *tableName,
-                                                        SWSSZmqClient zmqc, uint8_t dbPersistence) {
-
-    SWSSTry(return (SWSSZmqProducerStateTable) new ZmqProducerStateTable(
-        (DBConnector *)db, string(tableName), *(ZmqClient *)zmqc, dbPersistence));
+SWSSResult SWSSZmqProducerStateTable_new(SWSSDBConnector db, const char *tableName,
+                                         SWSSZmqClient zmqc, uint8_t dbPersistence,
+                                         SWSSZmqProducerStateTable *outTbl) {
+    SWSSTry(*outTbl = (SWSSZmqProducerStateTable) new ZmqProducerStateTable(
+                (DBConnector *)db, string(tableName), *(ZmqClient *)zmqc, dbPersistence));
 }
 
-void SWSSZmqProducerStateTable_free(SWSSZmqProducerStateTable tbl) {
+SWSSResult SWSSZmqProducerStateTable_free(SWSSZmqProducerStateTable tbl) {
     SWSSTry(delete (ZmqProducerStateTable *)tbl);
 }
 
-void SWSSZmqProducerStateTable_set(SWSSZmqProducerStateTable tbl, const char *key,
-                                   SWSSFieldValueArray values) {
+SWSSResult SWSSZmqProducerStateTable_set(SWSSZmqProducerStateTable tbl, const char *key,
+                                         SWSSFieldValueArray values) {
     SWSSTry(((ZmqProducerStateTable *)tbl)->set(string(key), takeFieldValueArray(values)));
 }
 
-void SWSSZmqProducerStateTable_del(SWSSZmqProducerStateTable tbl, const char *key) {
+SWSSResult SWSSZmqProducerStateTable_del(SWSSZmqProducerStateTable tbl, const char *key) {
     SWSSTry(((ZmqProducerStateTable *)tbl)->del(string(key)));
 }
 
-uint64_t SWSSZmqProducerStateTable_dbUpdaterQueueSize(SWSSZmqProducerStateTable tbl) {
-    SWSSTry(return numeric_cast<uint64_t>(((ZmqProducerStateTable *)tbl)->dbUpdaterQueueSize()));
+SWSSResult SWSSZmqProducerStateTable_dbUpdaterQueueSize(SWSSZmqProducerStateTable tbl,
+                                                        uint64_t *outSize) {
+    SWSSTry(*outSize =
+                numeric_cast<uint64_t>(((ZmqProducerStateTable *)tbl)->dbUpdaterQueueSize()));
 }
diff --git a/common/c-api/zmqproducerstatetable.h b/common/c-api/zmqproducerstatetable.h
index 08d059186..f308fbb02 100644
--- a/common/c-api/zmqproducerstatetable.h
+++ b/common/c-api/zmqproducerstatetable.h
@@ -2,6 +2,7 @@
 #define SWSS_COMMON_C_API_ZMQPRODUCERSTATETABLE_H
 
 #include "dbconnector.h"
+#include "result.h"
 #include "util.h"
 #include "zmqclient.h"
 
@@ -13,17 +14,18 @@ extern "C" {
 
 typedef struct SWSSZmqProducerStateTableOpaque *SWSSZmqProducerStateTable;
 
-SWSSZmqProducerStateTable SWSSZmqProducerStateTable_new(SWSSDBConnector db, const char *tableName,
-                                                        SWSSZmqClient zmqc, uint8_t dbPersistence);
+SWSSResult SWSSZmqProducerStateTable_new(SWSSDBConnector db, const char *tableName,
+                                         SWSSZmqClient zmqc, uint8_t dbPersistence,
+                                         SWSSZmqProducerStateTable *outTbl);
 
-void SWSSZmqProducerStateTable_free(SWSSZmqProducerStateTable tbl);
+SWSSResult SWSSZmqProducerStateTable_free(SWSSZmqProducerStateTable tbl);
 
-void SWSSZmqProducerStateTable_set(SWSSZmqProducerStateTable tbl, const char *key,
-                                   SWSSFieldValueArray values);
+SWSSResult SWSSZmqProducerStateTable_set(SWSSZmqProducerStateTable tbl, const char *key,
+                                         SWSSFieldValueArray values);
 
-void SWSSZmqProducerStateTable_del(SWSSZmqProducerStateTable tbl, const char *key);
+SWSSResult SWSSZmqProducerStateTable_del(SWSSZmqProducerStateTable tbl, const char *key);
 
-uint64_t SWSSZmqProducerStateTable_dbUpdaterQueueSize(SWSSZmqProducerStateTable tbl);
+SWSSResult SWSSZmqProducerStateTable_dbUpdaterQueueSize(SWSSZmqProducerStateTable tbl, uint64_t *outSize);
 
 #ifdef __cplusplus
 }
diff --git a/common/c-api/zmqserver.cpp b/common/c-api/zmqserver.cpp
index 50452e22d..b2937ae38 100644
--- a/common/c-api/zmqserver.cpp
+++ b/common/c-api/zmqserver.cpp
@@ -5,10 +5,10 @@
 using namespace swss;
 using namespace std;
 
-SWSSZmqServer SWSSZmqServer_new(const char *endpoint) {
-    SWSSTry(return (SWSSZmqServer) new ZmqServer(string(endpoint)));
+SWSSResult SWSSZmqServer_new(const char *endpoint, SWSSZmqServer *outZmqServer) {
+    SWSSTry(*outZmqServer = (SWSSZmqServer) new ZmqServer(string(endpoint)));
 }
 
-void SWSSZmqServer_free(SWSSZmqServer zmqs) {
+SWSSResult SWSSZmqServer_free(SWSSZmqServer zmqs) {
     SWSSTry(delete (ZmqServer *)zmqs);
 }
diff --git a/common/c-api/zmqserver.h b/common/c-api/zmqserver.h
index decd0e0dc..ee76af420 100644
--- a/common/c-api/zmqserver.h
+++ b/common/c-api/zmqserver.h
@@ -1,6 +1,7 @@
 #ifndef SWSS_COMMON_C_API_ZMQSERVER_H
 #define SWSS_COMMON_C_API_ZMQSERVER_H
 
+#include "result.h"
 #include "util.h"
 
 #ifdef __cplusplus
@@ -9,9 +10,9 @@ extern "C" {
 
 typedef struct SWSSZmqServerOpaque *SWSSZmqServer;
 
-SWSSZmqServer SWSSZmqServer_new(const char *endpoint);
+SWSSResult SWSSZmqServer_new(const char *endpoint, SWSSZmqServer *outZmqServer);
 
-void SWSSZmqServer_free(SWSSZmqServer zmqs);
+SWSSResult SWSSZmqServer_free(SWSSZmqServer zmqs);
 
 #ifdef __cplusplus
 }
diff --git a/tests/c_api_ut.cpp b/tests/c_api_ut.cpp
index f1019053e..fa70fce14 100644
--- a/tests/c_api_ut.cpp
+++ b/tests/c_api_ut.cpp
@@ -142,31 +142,39 @@ TEST(c_api, Table) {
     clearDB();
     SWSSStringManager sm;
 
-    SWSSDBConnector db = SWSSDBConnector_new_named("TEST_DB", 1000, true);
-    SWSSTable tbl = SWSSTable_new(db, "mytable");
+    SWSSDBConnector db;
+    SWSSDBConnector_new_named("TEST_DB", 1000, true, &db);
+    SWSSTable tbl;
+    SWSSTable_new(db, "mytable", &tbl);
 
     SWSSFieldValueArray fvs;
     SWSSString ss;
-    EXPECT_FALSE(SWSSTable_get(tbl, "mykey", &fvs));
-    EXPECT_FALSE(SWSSTable_hget(tbl, "mykey", "myfield", &ss));
+    int8_t exists;
+    SWSSTable_get(tbl, "mykey", &fvs, &exists);
+    EXPECT_FALSE(exists);
+    SWSSTable_hget(tbl, "mykey", "myfield", &ss, &exists);
+    EXPECT_FALSE(exists);
 
-    SWSSStringArray keys = SWSSTable_getKeys(tbl);
+    SWSSStringArray keys;
+    SWSSTable_getKeys(tbl, &keys);
     EXPECT_EQ(keys.len, 0);
     SWSSStringArray_free(keys);
 
     SWSSTable_hset(tbl, "mykey", "myfield", sm.makeStrRef("myvalue"));
-    keys = SWSSTable_getKeys(tbl);
+    SWSSTable_getKeys(tbl, &keys);
     ASSERT_EQ(keys.len, 1);
     EXPECT_STREQ(keys.data[0], "mykey");
     free(keys.data[0]);
     SWSSStringArray_free(keys);
 
-    ASSERT_TRUE(SWSSTable_hget(tbl, "mykey", "myfield", &ss));
+    SWSSTable_hget(tbl, "mykey", "myfield", &ss, &exists);
+    ASSERT_TRUE(exists);
     EXPECT_STREQ(SWSSStrRef_c_str((SWSSStrRef)ss), "myvalue");
     SWSSString_free(ss);
 
     SWSSTable_hdel(tbl, "mykey", "myfield");
-    EXPECT_FALSE(SWSSTable_hget(tbl, "mykey", "myfield", &ss));
+    SWSSTable_hget(tbl, "mykey", "myfield", &ss, &exists);
+    EXPECT_FALSE(exists);
 
     SWSSFieldValueTuple data[2] = {{.field = "myfield1", .value = sm.makeString("myvalue1")},
                                    {.field = "myfield2", .value = sm.makeString("myvalue2")}};
@@ -174,14 +182,15 @@ TEST(c_api, Table) {
     fvs.data = data;
     SWSSTable_set(tbl, "mykey", fvs);
 
-    ASSERT_TRUE(SWSSTable_get(tbl, "mykey", &fvs));
-    EXPECT_EQ(fvs.len, 2);
+    SWSSTable_get(tbl, "mykey", &fvs, &exists);
+    ASSERT_TRUE(exists);
+    ASSERT_EQ(fvs.len, 2);
     EXPECT_STREQ(data[0].field, fvs.data[0].field);
     EXPECT_STREQ(data[1].field, fvs.data[1].field);
     freeFieldValuesArray(fvs);
 
     SWSSTable_del(tbl, "mykey");
-    keys = SWSSTable_getKeys(tbl);
+    SWSSTable_getKeys(tbl, &keys);
     EXPECT_EQ(keys.len, 0);
     SWSSStringArray_free(keys);
 
@@ -193,13 +202,18 @@ TEST(c_api, ConsumerProducerStateTables) {
     clearDB();
     SWSSStringManager sm;
 
-    SWSSDBConnector db = SWSSDBConnector_new_named("TEST_DB", 1000, true);
-    SWSSProducerStateTable pst = SWSSProducerStateTable_new(db, "mytable");
-    SWSSConsumerStateTable cst = SWSSConsumerStateTable_new(db, "mytable", nullptr, nullptr);
+    SWSSDBConnector db;
+    SWSSDBConnector_new_named("TEST_DB", 1000, true, &db);
+    SWSSProducerStateTable pst;
+    SWSSProducerStateTable_new(db, "mytable", &pst);
+    SWSSConsumerStateTable cst;
+    SWSSConsumerStateTable_new(db, "mytable", nullptr, nullptr, &cst);
 
-    SWSSConsumerStateTable_getFd(cst);
+    uint32_t fd;
+    SWSSConsumerStateTable_getFd(cst, &fd);
 
-    SWSSKeyOpFieldValuesArray arr = SWSSConsumerStateTable_pops(cst);
+    SWSSKeyOpFieldValuesArray arr;
+    SWSSConsumerStateTable_pops(cst, &arr);
     ASSERT_EQ(arr.len, 0);
     freeKeyOpFieldValuesArray(arr);
 
@@ -215,8 +229,9 @@ TEST(c_api, ConsumerProducerStateTables) {
     values.len = 1;
     SWSSProducerStateTable_set(pst, "mykey2", values);
 
-    ASSERT_EQ(SWSSConsumerStateTable_readData(cst, 300, true), SWSSSelectResult_DATA);
-    arr = SWSSConsumerStateTable_pops(cst);
+    SWSSSelectResult result;
+    SWSSConsumerStateTable_readData(cst, 300, true, &result);
+    SWSSConsumerStateTable_pops(cst, &arr);
     vector<KeyOpFieldsValuesTuple> kfvs = takeKeyOpFieldValuesArray(arr);
     sortKfvs(kfvs);
     freeKeyOpFieldValuesArray(arr);
@@ -238,7 +253,7 @@ TEST(c_api, ConsumerProducerStateTables) {
     EXPECT_EQ(fieldValues1[0].first, "myfield3");
     EXPECT_EQ(fieldValues1[0].second, "myvalue3");
 
-    arr = SWSSConsumerStateTable_pops(cst);
+    SWSSConsumerStateTable_pops(cst, &arr);
     EXPECT_EQ(arr.len, 0);
     freeKeyOpFieldValuesArray(arr);
 
@@ -246,7 +261,7 @@ TEST(c_api, ConsumerProducerStateTables) {
     SWSSProducerStateTable_del(pst, "mykey4");
     SWSSProducerStateTable_del(pst, "mykey5");
 
-    arr = SWSSConsumerStateTable_pops(cst);
+    SWSSConsumerStateTable_pops(cst, &arr);
     kfvs = takeKeyOpFieldValuesArray(arr);
     sortKfvs(kfvs);
     freeKeyOpFieldValuesArray(arr);
@@ -264,7 +279,8 @@ TEST(c_api, ConsumerProducerStateTables) {
 
     SWSSProducerStateTable_free(pst);
     SWSSConsumerStateTable_free(cst);
-    SWSSDBConnector_flushdb(db);
+    int8_t flushStatus;
+    SWSSDBConnector_flushdb(db, &flushStatus);
     SWSSDBConnector_free(db);
 }
 
@@ -272,19 +288,26 @@ TEST(c_api, SubscriberStateTable) {
     clearDB();
     SWSSStringManager sm;
 
-    SWSSDBConnector db = SWSSDBConnector_new_named("TEST_DB", 1000, true);
-    SWSSSubscriberStateTable sst = SWSSSubscriberStateTable_new(db, "mytable", nullptr, nullptr);
+    SWSSDBConnector db;
+    SWSSDBConnector_new_named("TEST_DB", 1000, true, &db);
+    SWSSSubscriberStateTable sst;
+    SWSSSubscriberStateTable_new(db, "mytable", nullptr, nullptr, &sst);
 
-    SWSSSubscriberStateTable_getFd(sst);
+    uint32_t fd;
+    SWSSSubscriberStateTable_getFd(sst, &fd);
 
-    EXPECT_EQ(SWSSSubscriberStateTable_readData(sst, 300, true), SWSSSelectResult_TIMEOUT);
-    SWSSKeyOpFieldValuesArray arr = SWSSSubscriberStateTable_pops(sst);
+    SWSSSelectResult result;
+    SWSSSubscriberStateTable_readData(sst, 300, true, &result);
+    EXPECT_EQ(result, SWSSSelectResult_TIMEOUT);
+    SWSSKeyOpFieldValuesArray arr;
+    SWSSSubscriberStateTable_pops(sst, &arr);
     EXPECT_EQ(arr.len, 0);
     freeKeyOpFieldValuesArray(arr);
 
     SWSSDBConnector_hset(db, "mytable:mykey", "myfield", sm.makeStrRef("myvalue"));
-    EXPECT_EQ(SWSSSubscriberStateTable_readData(sst, 300, true), SWSSSelectResult_DATA);
-    arr = SWSSSubscriberStateTable_pops(sst);
+    SWSSSubscriberStateTable_readData(sst, 300, true, &result);
+    EXPECT_EQ(result, SWSSSelectResult_DATA);
+    SWSSSubscriberStateTable_pops(sst, &arr);
     vector<KeyOpFieldsValuesTuple> kfvs = takeKeyOpFieldValuesArray(arr);
     sortKfvs(kfvs);
     freeKeyOpFieldValuesArray(arr);
@@ -297,7 +320,8 @@ TEST(c_api, SubscriberStateTable) {
     EXPECT_EQ(kfvFieldsValues(kfvs[0])[0].second, "myvalue");
 
     SWSSSubscriberStateTable_free(sst);
-    SWSSDBConnector_flushdb(db);
+    int8_t flushStatus;
+    SWSSDBConnector_flushdb(db, &flushStatus);
     SWSSDBConnector_free(db);
 }
 
@@ -305,27 +329,35 @@ TEST(c_api, ZmqConsumerProducerStateTable) {
     clearDB();
     SWSSStringManager sm;
 
-    SWSSDBConnector db = SWSSDBConnector_new_named("TEST_DB", 1000, true);
-
-    SWSSZmqServer srv = SWSSZmqServer_new("tcp://127.0.0.1:42312");
-    SWSSZmqClient cli = SWSSZmqClient_new("tcp://127.0.0.1:42312");
-    EXPECT_TRUE(SWSSZmqClient_isConnected(cli));
-    SWSSZmqClient_connect(cli); // This should be idempotent/not throw
-
-    SWSSZmqProducerStateTable pst = SWSSZmqProducerStateTable_new(db, "mytable", cli, false);
-    SWSSZmqConsumerStateTable cst =
-        SWSSZmqConsumerStateTable_new(db, "mytable", srv, nullptr, nullptr);
-
-    SWSSZmqConsumerStateTable_getFd(cst);
-
-    ASSERT_EQ(SWSSZmqConsumerStateTable_getDbConnector(cst), db);
+    SWSSDBConnector db;
+    SWSSDBConnector_new_named("TEST_DB", 1000, true, &db);
 
-    SWSSKeyOpFieldValuesArray arr = SWSSZmqConsumerStateTable_pops(cst);
+    SWSSZmqServer srv;
+    SWSSZmqServer_new("tcp://127.0.0.1:42312", &srv);
+    SWSSZmqClient cli;
+    SWSSZmqClient_new("tcp://127.0.0.1:42312", &cli);
+    int8_t isConnected;
+    SWSSZmqClient_isConnected(cli, &isConnected);
+    ASSERT_TRUE(isConnected);
+    SWSSZmqClient_connect(cli);
+
+    SWSSZmqProducerStateTable pst;
+    SWSSZmqProducerStateTable_new(db, "mytable", cli, false, &pst);
+    SWSSZmqConsumerStateTable cst;
+    SWSSZmqConsumerStateTable_new(db, "mytable", srv, nullptr, nullptr, &cst);
+
+    uint32_t fd;
+    SWSSZmqConsumerStateTable_getFd(cst, &fd);
+
+    const SWSSDBConnectorOpaque *dbConnector;
+    SWSSZmqConsumerStateTable_getDbConnector(cst, &dbConnector);
+    ASSERT_EQ(dbConnector, db);
+
+    SWSSKeyOpFieldValuesArray arr;
+    SWSSZmqConsumerStateTable_pops(cst, &arr);
     ASSERT_EQ(arr.len, 0);
     freeKeyOpFieldValuesArray(arr);
 
-    // On flag = 0, we use the ZmqProducerStateTable
-    // On flag = 1, we use the ZmqClient directly
     for (int flag = 0; flag < 2; flag++) {
         SWSSFieldValueTuple values_key1_data[2] = {
             {.field = "myfield1", .value = sm.makeString("myvalue1")},
@@ -353,8 +385,9 @@ TEST(c_api, ZmqConsumerProducerStateTable) {
         else
             SWSSZmqClient_sendMsg(cli, "TEST_DB", "mytable", arr);
 
-        ASSERT_EQ(SWSSZmqConsumerStateTable_readData(cst, 1500, true), SWSSSelectResult_DATA);
-        arr = SWSSZmqConsumerStateTable_pops(cst);
+        SWSSSelectResult result;
+        SWSSZmqConsumerStateTable_readData(cst, 1500, true, &result);
+        SWSSZmqConsumerStateTable_pops(cst, &arr);
 
         vector<KeyOpFieldsValuesTuple> kfvs = takeKeyOpFieldValuesArray(arr);
         sortKfvs(kfvs);
@@ -377,7 +410,7 @@ TEST(c_api, ZmqConsumerProducerStateTable) {
         EXPECT_EQ(fieldValues1[0].first, "myfield3");
         EXPECT_EQ(fieldValues1[0].second, "myvalue3");
 
-        arr = SWSSZmqConsumerStateTable_pops(cst);
+        SWSSZmqConsumerStateTable_pops(cst, &arr);
         ASSERT_EQ(arr.len, 0);
         freeKeyOpFieldValuesArray(arr);
 
@@ -391,8 +424,8 @@ TEST(c_api, ZmqConsumerProducerStateTable) {
         else
             SWSSZmqClient_sendMsg(cli, "TEST_DB", "mytable", arr);
 
-        ASSERT_EQ(SWSSZmqConsumerStateTable_readData(cst, 500, true), SWSSSelectResult_DATA);
-        arr = SWSSZmqConsumerStateTable_pops(cst);
+        SWSSZmqConsumerStateTable_readData(cst, 500, true, &result);
+        SWSSZmqConsumerStateTable_pops(cst, &arr);
 
         kfvs = takeKeyOpFieldValuesArray(arr);
         sortKfvs(kfvs);
@@ -407,7 +440,6 @@ TEST(c_api, ZmqConsumerProducerStateTable) {
         EXPECT_EQ(kfvFieldsValues(kfvs[1]).size(), 0);
     }
 
-    // Server must be freed first to safely release message handlers (ZmqConsumerStateTable)
     SWSSZmqServer_free(srv);
 
     SWSSZmqProducerStateTable_free(pst);
@@ -415,6 +447,7 @@ TEST(c_api, ZmqConsumerProducerStateTable) {
 
     SWSSZmqClient_free(cli);
 
-    SWSSDBConnector_flushdb(db);
+    int8_t flushStatus;
+    SWSSDBConnector_flushdb(db, &flushStatus);
     SWSSDBConnector_free(db);
 }
diff --git a/tests/main.cpp b/tests/main.cpp
index 440978a46..bfdd9fcdb 100644
--- a/tests/main.cpp
+++ b/tests/main.cpp
@@ -85,9 +85,6 @@ class SwsscommonEnvironment : public ::testing::Environment {
         SonicDBConfig::initializeGlobalConfig(global_existing_file);
         cout<<"INIT: load global db config file, isInit = "<<SonicDBConfig::isGlobalInit()<<endl;
         EXPECT_TRUE(SonicDBConfig::isGlobalInit());
-
-        // Disable aborts for the c api so that EXPECT_THROW will work as intended
-        swss::cApiTestingDisableAbort = true;
     }
 };