diff --git a/src/app-layer-expectation.c b/src/app-layer-expectation.c
index ef7f08a4d4..91064aaa64 100644
--- a/src/app-layer-expectation.c
+++ b/src/app-layer-expectation.c
@@ -62,7 +62,7 @@
 
 #include "util-print.h"
 
-static IPPairStorageId g_ippair_expectation_id = { .id = -1 };
+static SCIPPairStorageId g_ippair_expectation_id = { .id = -1 };
 static SCFlowStorageId g_flow_expectation_id = { .id = -1 };
 
 SC_ATOMIC_DECLARE(uint32_t, expectation_count);
@@ -145,7 +145,7 @@ uint64_t ExpectationGetCounter(void)
 
 void AppLayerExpectationSetup(void)
 {
-    g_ippair_expectation_id = IPPairStorageRegister("expectation", ExpectationListFree);
+    g_ippair_expectation_id = SCIPPairStorageRegister("expectation", ExpectationListFree);
     g_flow_expectation_id = SCFlowStorageRegister("expectation", ExpectationDataFree);
     SC_ATOMIC_INIT(expectation_count);
 }
@@ -176,7 +176,7 @@ static ExpectationList *AppLayerExpectationLookup(Flow *f, IPPair **ipp)
         return NULL;
     }
 
-    return IPPairGetStorageById(*ipp, g_ippair_expectation_id);
+    return SCIPPairGetStorageById(*ipp, g_ippair_expectation_id);
 }
 
 
@@ -189,7 +189,7 @@ static ExpectationList *AppLayerExpectationRemove(IPPair *ipp,
     SC_ATOMIC_SUB(expectation_count, 1);
     exp_list->length--;
     if (exp_list->length == 0) {
-        IPPairSetStorageById(ipp, g_ippair_expectation_id, NULL);
+        SCIPPairSetStorageById(ipp, g_ippair_expectation_id, NULL);
         ExpectationListFree(exp_list);
         exp_list = NULL;
     }
@@ -239,7 +239,7 @@ int AppLayerExpectationCreate(Flow *f, int direction, Port src, Port dst,
     if (ipp == NULL)
         goto error;
 
-    exp_list = IPPairGetStorageById(ipp, g_ippair_expectation_id);
+    exp_list = SCIPPairGetStorageById(ipp, g_ippair_expectation_id);
     if (exp_list) {
         CIRCLEQ_INSERT_HEAD(&exp_list->list, exp, entries);
         /* In case there is already EXPECTATION_MAX_LEVEL expectations waiting to be fulfilled,
@@ -261,7 +261,7 @@ int AppLayerExpectationCreate(Flow *f, int direction, Port src, Port dst,
         exp_list->length = 0;
         CIRCLEQ_INIT(&exp_list->list);
         CIRCLEQ_INSERT_HEAD(&exp_list->list, exp, entries);
-        IPPairSetStorageById(ipp, g_ippair_expectation_id, exp_list);
+        SCIPPairSetStorageById(ipp, g_ippair_expectation_id, exp_list);
     }
 
     exp_list->length += 1;
diff --git a/src/ippair-bit.c b/src/ippair-bit.c
index cb3237bd43..be455afb91 100644
--- a/src/ippair-bit.c
+++ b/src/ippair-bit.c
@@ -38,7 +38,7 @@
 #include "util-unittest.h"
 #include "ippair-storage.h"
 
-static IPPairStorageId g_ippair_bit_storage_id = { .id = -1 }; /**< IPPair storage id for bits */
+static SCIPPairStorageId g_ippair_bit_storage_id = { .id = -1 }; /**< IPPair storage id for bits */
 
 static void XBitFreeAll(void *store)
 {
@@ -48,7 +48,7 @@ static void XBitFreeAll(void *store)
 
 void IPPairBitInitCtx(void)
 {
-    g_ippair_bit_storage_id = IPPairStorageRegister("bit", XBitFreeAll);
+    g_ippair_bit_storage_id = SCIPPairStorageRegister("bit", XBitFreeAll);
     if (g_ippair_bit_storage_id.id == -1) {
         FatalError("Can't initiate ippair storage for bits");
     }
@@ -59,14 +59,14 @@ int IPPairHasBits(IPPair *ippair)
 {
     if (ippair == NULL)
         return 0;
-    return IPPairGetStorageById(ippair, g_ippair_bit_storage_id) ? 1 : 0;
+    return SCIPPairGetStorageById(ippair, g_ippair_bit_storage_id) ? 1 : 0;
 }
 
 /** \retval 1 ippair timed out wrt xbits
   * \retval 0 ippair still has active (non-expired) xbits */
 int IPPairBitsTimedoutCheck(IPPair *h, SCTime_t ts)
 {
-    GenericVar *gv = IPPairGetStorageById(h, g_ippair_bit_storage_id);
+    GenericVar *gv = SCIPPairGetStorageById(h, g_ippair_bit_storage_id);
     for ( ; gv != NULL; gv = gv->next) {
         if (gv->type == DETECT_XBITS) {
             XBit *xb = (XBit *)gv;
@@ -80,7 +80,7 @@ int IPPairBitsTimedoutCheck(IPPair *h, SCTime_t ts)
 /* get the bit with idx from the ippair */
 static XBit *IPPairBitGet(IPPair *h, uint32_t idx)
 {
-    GenericVar *gv = IPPairGetStorageById(h, g_ippair_bit_storage_id);
+    GenericVar *gv = SCIPPairGetStorageById(h, g_ippair_bit_storage_id);
     for ( ; gv != NULL; gv = gv->next) {
         if (gv->type == DETECT_XBITS && gv->idx == idx) {
             return (XBit *)gv;
@@ -104,9 +104,9 @@ static void IPPairBitAdd(IPPair *h, uint32_t idx, SCTime_t expire)
         fb->next = NULL;
         fb->expire = expire;
 
-        GenericVar *gv = IPPairGetStorageById(h, g_ippair_bit_storage_id);
+        GenericVar *gv = SCIPPairGetStorageById(h, g_ippair_bit_storage_id);
         GenericVarAppend(&gv, (GenericVar *)fb);
-        IPPairSetStorageById(h, g_ippair_bit_storage_id, gv);
+        SCIPPairSetStorageById(h, g_ippair_bit_storage_id, gv);
 
         // bit already set, lets update it's timer
     } else {
@@ -120,11 +120,11 @@ static void IPPairBitRemove(IPPair *h, uint32_t idx)
     if (fb == NULL)
         return;
 
-    GenericVar *gv = IPPairGetStorageById(h, g_ippair_bit_storage_id);
+    GenericVar *gv = SCIPPairGetStorageById(h, g_ippair_bit_storage_id);
     if (gv) {
         GenericVarRemove(&gv, (GenericVar *)fb);
         XBitFree(fb);
-        IPPairSetStorageById(h, g_ippair_bit_storage_id, gv);
+        SCIPPairSetStorageById(h, g_ippair_bit_storage_id, gv);
     }
 }
 
diff --git a/src/ippair-storage.c b/src/ippair-storage.c
index f57717805d..45e470f45e 100644
--- a/src/ippair-storage.c
+++ b/src/ippair-storage.c
@@ -27,31 +27,31 @@
 #include "ippair-storage.h"
 #include "util-unittest.h"
 
-unsigned int IPPairStorageSize(void)
+unsigned int SCIPPairStorageSize(void)
 {
     return StorageGetSize(STORAGE_IPPAIR);
 }
 
-void *IPPairGetStorageById(IPPair *h, IPPairStorageId id)
+void *SCIPPairGetStorageById(IPPair *h, SCIPPairStorageId id)
 {
     return StorageGetById(h->storage, STORAGE_IPPAIR, id.id);
 }
 
-int IPPairSetStorageById(IPPair *h, IPPairStorageId id, void *ptr)
+int SCIPPairSetStorageById(IPPair *h, SCIPPairStorageId id, void *ptr)
 {
     return StorageSetById(h->storage, STORAGE_IPPAIR, id.id, ptr);
 }
 
-void IPPairFreeStorage(IPPair *h)
+void SCIPPairFreeStorage(IPPair *h)
 {
-    if (IPPairStorageSize() > 0)
+    if (SCIPPairStorageSize() > 0)
         StorageFreeAll(h->storage, STORAGE_IPPAIR);
 }
 
-IPPairStorageId IPPairStorageRegister(const char *name, void (*Free)(void *))
+SCIPPairStorageId SCIPPairStorageRegister(const char *name, void (*Free)(void *))
 {
     int id = StorageRegister(STORAGE_IPPAIR, name, Free);
-    IPPairStorageId ippsi = { .id = id };
+    SCIPPairStorageId ippsi = { .id = id };
     return ippsi;
 }
 
@@ -68,11 +68,11 @@ static int IPPairStorageTest01(void)
     StorageCleanup();
     StorageInit();
 
-    IPPairStorageId id1 = IPPairStorageRegister("test", StorageTestFree);
+    SCIPPairStorageId id1 = SCIPPairStorageRegister("test", StorageTestFree);
     FAIL_IF(id1.id < 0);
-    IPPairStorageId id2 = IPPairStorageRegister("variable", StorageTestFree);
+    SCIPPairStorageId id2 = SCIPPairStorageRegister("variable", StorageTestFree);
     FAIL_IF(id2.id < 0);
-    IPPairStorageId id3 = IPPairStorageRegister("store", StorageTestFree);
+    SCIPPairStorageId id3 = SCIPPairStorageRegister("store", StorageTestFree);
     FAIL_IF(id3.id < 0);
 
     FAIL_IF(StorageFinalize() < 0);
@@ -89,28 +89,28 @@ static int IPPairStorageTest01(void)
     IPPair *h = IPPairGetIPPairFromHash(&a, &b);
     FAIL_IF_NULL(h);
 
-    void *ptr = IPPairGetStorageById(h, id1);
+    void *ptr = SCIPPairGetStorageById(h, id1);
     FAIL_IF_NOT_NULL(ptr);
-    ptr = IPPairGetStorageById(h, id2);
+    ptr = SCIPPairGetStorageById(h, id2);
     FAIL_IF_NOT_NULL(ptr);
-    ptr = IPPairGetStorageById(h, id3);
+    ptr = SCIPPairGetStorageById(h, id3);
     FAIL_IF_NOT_NULL(ptr);
 
     void *ptr1a = SCMalloc(8);
     FAIL_IF(ptr1a == NULL);
-    FAIL_IF(IPPairSetStorageById(h, id1, ptr1a) != 0);
+    FAIL_IF(SCIPPairSetStorageById(h, id1, ptr1a) != 0);
     void *ptr2a = SCMalloc(24);
     FAIL_IF(ptr2a == NULL);
-    FAIL_IF(IPPairSetStorageById(h, id2, ptr2a) != 0);
+    FAIL_IF(SCIPPairSetStorageById(h, id2, ptr2a) != 0);
     void *ptr3a = SCMalloc(16);
     FAIL_IF(ptr3a == NULL);
-    FAIL_IF(IPPairSetStorageById(h, id3, ptr3a) != 0);
+    FAIL_IF(SCIPPairSetStorageById(h, id3, ptr3a) != 0);
 
-    void *ptr1b = IPPairGetStorageById(h, id1);
+    void *ptr1b = SCIPPairGetStorageById(h, id1);
     FAIL_IF(ptr1a != ptr1b);
-    void *ptr2b = IPPairGetStorageById(h, id2);
+    void *ptr2b = SCIPPairGetStorageById(h, id2);
     FAIL_IF(ptr2a != ptr2b);
-    void *ptr3b = IPPairGetStorageById(h, id3);
+    void *ptr3b = SCIPPairGetStorageById(h, id3);
     FAIL_IF(ptr3a != ptr3b);
 
     IPPairRelease(h);
@@ -124,7 +124,7 @@ static int IPPairStorageTest02(void)
     StorageCleanup();
     StorageInit();
 
-    IPPairStorageId id1 = IPPairStorageRegister("test", StorageTestFree);
+    SCIPPairStorageId id1 = SCIPPairStorageRegister("test", StorageTestFree);
     FAIL_IF(id1.id < 0);
 
     FAIL_IF(StorageFinalize() < 0);
@@ -141,15 +141,15 @@ static int IPPairStorageTest02(void)
     IPPair *h = IPPairGetIPPairFromHash(&a, &b);
     FAIL_IF(h == NULL);
 
-    void *ptr = IPPairGetStorageById(h, id1);
+    void *ptr = SCIPPairGetStorageById(h, id1);
     FAIL_IF_NOT_NULL(ptr);
 
     void *ptr1a = SCMalloc(128);
     FAIL_IF(ptr1a == NULL);
 
-    IPPairSetStorageById(h, id1, ptr1a);
+    SCIPPairSetStorageById(h, id1, ptr1a);
 
-    void *ptr1b = IPPairGetStorageById(h, id1);
+    void *ptr1b = SCIPPairGetStorageById(h, id1);
     FAIL_IF(ptr1a != ptr1b);
 
     IPPairRelease(h);
@@ -163,11 +163,11 @@ static int IPPairStorageTest03(void)
     StorageCleanup();
     StorageInit();
 
-    IPPairStorageId id1 = IPPairStorageRegister("test1", StorageTestFree);
+    SCIPPairStorageId id1 = SCIPPairStorageRegister("test1", StorageTestFree);
     FAIL_IF(id1.id < 0);
-    IPPairStorageId id2 = IPPairStorageRegister("test2", StorageTestFree);
+    SCIPPairStorageId id2 = SCIPPairStorageRegister("test2", StorageTestFree);
     FAIL_IF(id2.id < 0);
-    IPPairStorageId id3 = IPPairStorageRegister("test3", StorageTestFree);
+    SCIPPairStorageId id3 = SCIPPairStorageRegister("test3", StorageTestFree);
     FAIL_IF(id3.id < 0);
 
     FAIL_IF(StorageFinalize() < 0);
@@ -184,28 +184,28 @@ static int IPPairStorageTest03(void)
     IPPair *h = IPPairGetIPPairFromHash(&a, &b);
     FAIL_IF(h == NULL);
 
-    void *ptr = IPPairGetStorageById(h, id1);
+    void *ptr = SCIPPairGetStorageById(h, id1);
     FAIL_IF_NOT_NULL(ptr);
 
     void *ptr1a = SCMalloc(128);
     FAIL_IF(ptr1a == NULL);
 
-    IPPairSetStorageById(h, id1, ptr1a);
+    SCIPPairSetStorageById(h, id1, ptr1a);
 
     void *ptr2a = SCMalloc(256);
     FAIL_IF(ptr2a == NULL);
 
-    IPPairSetStorageById(h, id2, ptr2a);
+    SCIPPairSetStorageById(h, id2, ptr2a);
 
     void *ptr3a = SCMalloc(32);
     FAIL_IF(ptr3a == NULL);
-    IPPairSetStorageById(h, id3, ptr3a);
+    SCIPPairSetStorageById(h, id3, ptr3a);
 
-    void *ptr1b = IPPairGetStorageById(h, id1);
+    void *ptr1b = SCIPPairGetStorageById(h, id1);
     FAIL_IF(ptr1a != ptr1b);
-    void *ptr2b = IPPairGetStorageById(h, id2);
+    void *ptr2b = SCIPPairGetStorageById(h, id2);
     FAIL_IF(ptr2a != ptr2b);
-    void *ptr3b = IPPairGetStorageById(h, id3);
+    void *ptr3b = SCIPPairGetStorageById(h, id3);
     FAIL_IF(ptr3a != ptr3b);
 
     IPPairRelease(h);
@@ -215,7 +215,7 @@ static int IPPairStorageTest03(void)
 }
 #endif
 
-void RegisterIPPairStorageTests(void)
+void SCRegisterIPPairStorageTests(void)
 {
 #ifdef UNITTESTS
     UtRegisterTest("IPPairStorageTest01", IPPairStorageTest01);
diff --git a/src/ippair-storage.h b/src/ippair-storage.h
index 3c853f33a5..dd13887996 100644
--- a/src/ippair-storage.h
+++ b/src/ippair-storage.h
@@ -28,19 +28,19 @@
 
 #include "ippair.h"
 
-typedef struct IPPairStorageId {
+typedef struct SCIPPairStorageId {
     int id;
-} IPPairStorageId;
+} SCIPPairStorageId;
 
-unsigned int IPPairStorageSize(void);
+unsigned int SCIPPairStorageSize(void);
 
-void *IPPairGetStorageById(IPPair *h, IPPairStorageId id);
-int IPPairSetStorageById(IPPair *h, IPPairStorageId id, void *ptr);
+void *SCIPPairGetStorageById(IPPair *h, SCIPPairStorageId id);
+int SCIPPairSetStorageById(IPPair *h, SCIPPairStorageId id, void *ptr);
 
-void IPPairFreeStorage(IPPair *h);
+void SCIPPairFreeStorage(IPPair *h);
 
-void RegisterIPPairStorageTests(void);
+void SCRegisterIPPairStorageTests(void);
 
-IPPairStorageId IPPairStorageRegister(const char *name, void (*Free)(void *));
+SCIPPairStorageId SCIPPairStorageRegister(const char *name, void (*Free)(void *));
 
 #endif /* SURICATA_IPPAIR_STORAGE_H */
diff --git a/src/ippair.c b/src/ippair.c
index 12480ee6cd..6683461aa8 100644
--- a/src/ippair.c
+++ b/src/ippair.c
@@ -149,8 +149,8 @@ error:
 
 void IPPairClearMemory(IPPair *h)
 {
-    if (IPPairStorageSize() > 0)
-        IPPairFreeStorage(h);
+    if (SCIPPairStorageSize() > 0)
+        SCIPPairFreeStorage(h);
 }
 
 #define IPPAIR_DEFAULT_HASHSIZE 4096
@@ -162,9 +162,9 @@ void IPPairClearMemory(IPPair *h)
 void IPPairInitConfig(bool quiet)
 {
     SCLogDebug("initializing ippair engine...");
-    if (IPPairStorageSize() > 0) {
-        DEBUG_VALIDATE_BUG_ON(sizeof(IPPair) + IPPairStorageSize() > UINT16_MAX);
-        g_ippair_size = (uint16_t)(sizeof(IPPair) + IPPairStorageSize());
+    if (SCIPPairStorageSize() > 0) {
+        DEBUG_VALIDATE_BUG_ON(sizeof(IPPair) + SCIPPairStorageSize() > UINT16_MAX);
+        g_ippair_size = (uint16_t)(sizeof(IPPair) + SCIPPairStorageSize());
     }
 
     memset(&ippair_config,  0, sizeof(ippair_config));
@@ -334,7 +334,7 @@ void IPPairCleanup(void)
             while (h) {
                 if ((SC_ATOMIC_GET(h->use_cnt) > 0)) {
                     /* iprep is attached to ippair only clear local storage */
-                    IPPairFreeStorage(h);
+                    SCIPPairFreeStorage(h);
                     h = h->hnext;
                 } else {
                     IPPair *n = h->hnext;
@@ -751,5 +751,5 @@ static IPPair *IPPairGetUsedIPPair(void)
 
 void IPPairRegisterUnittests(void)
 {
-    RegisterIPPairStorageTests();
+    SCRegisterIPPairStorageTests();
 }