Merge branch 'libcache' of https://github.com/vel21ripn/nDPI into vel21ripn-libcache

2 files changed, 46 insertions, 33 deletions

diff --git a/src/lib/third_party/include/libcache.h b/src/lib/third_party/include/libcache.h
index 53632616e..7f84b89ad 100644
--- a/src/lib/third_party/include/libcache.h
+++ b/src/lib/third_party/include/libcache.h
@@ -29,6 +29,10 @@ SOFTWARE.
 
 #include <stdint.h>
 
+typedef struct cache_entry *cache_entry;
+
+typedef struct cache_entry_map *cache_entry_map;
+
 /**
  * @brief Codes representing the result of some functions
  *
@@ -99,5 +103,7 @@ cache_result cache_remove(cache_t cache, void *item, uint32_t item_size);
  */
 void cache_free(cache_t cache);
 
+cache_entry cache_entry_new(void);
+cache_entry_map cache_entry_map_new(void);
 
 #endif
diff --git a/src/lib/third_party/src/libcache.c b/src/lib/third_party/src/libcache.c
index af53c9813..4479ff54d 100644
--- a/src/lib/third_party/src/libcache.c
+++ b/src/lib/third_party/src/libcache.c
@@ -30,6 +30,7 @@ SOFTWARE.
 #include <string.h>
 
 #include "libcache.h"
+#include "ndpi_api.h"
 
 
 // https://en.wikipedia.org/wiki/Jenkins_hash_function
@@ -49,10 +50,6 @@ uint32_t jenkins_one_at_a_time_hash(const uint8_t* key, size_t length) {
 }
 
 
-typedef struct cache_entry *cache_entry;
-
-typedef struct cache_entry_map *cache_entry_map;
-
 struct cache {
   uint32_t size;
   uint32_t max_size;
@@ -91,19 +88,20 @@ void cache_touch_entry(cache_t cache, cache_entry entry) {
 }
 
 
-cache_entry cache_entry_new() {
-  return (cache_entry) calloc(sizeof(struct cache_entry), 1);
+cache_entry cache_entry_new(void) {
+  return (cache_entry) ndpi_calloc(sizeof(struct cache_entry), 1);
 }
-cache_entry_map cache_entry_map_new() {
-  return (cache_entry_map) calloc(sizeof(struct cache_entry_map), 1);
+cache_entry_map cache_entry_map_new(void) {
+  return (cache_entry_map) ndpi_calloc(sizeof(struct cache_entry_map), 1);
 }
 
 cache_t cache_new(uint32_t cache_max_size) {
+  cache_t cache;
   if(!cache_max_size) {
     return NULL;
   }
 
-  cache_t cache = (cache_t) calloc(sizeof(struct cache), 1);
+  cache = (cache_t) ndpi_calloc(sizeof(struct cache), 1);
   if(!cache) {
     return NULL;
   }
@@ -111,10 +109,10 @@ cache_t cache_new(uint32_t cache_max_size) {
   cache->size = 0;
   cache->max_size = cache_max_size;
 
-  cache->map = (cache_entry_map *) calloc(sizeof(cache_entry_map ), cache->max_size);
+  cache->map = (cache_entry_map *) ndpi_calloc(sizeof(cache_entry_map ), cache->max_size);
 
   if(!cache->map) {
-    free(cache);
+    ndpi_free(cache);
     return NULL;
   }
 
@@ -122,11 +120,15 @@ cache_t cache_new(uint32_t cache_max_size) {
 }
 
 cache_result cache_add(cache_t cache, void *item, uint32_t item_size) {
+  uint32_t hash;
+  cache_entry entry;
+  cache_entry_map map_entry;
+
   if(!cache || !item || !item_size) {
     return CACHE_INVALID_INPUT;
   }
 
-  uint32_t hash = HASH_FUNCTION(item, item_size) % cache->max_size;
+  hash = HASH_FUNCTION(item, item_size) % cache->max_size;
 
   if((cache->map)[hash]) {
     cache_entry_map hash_entry_map = cache->map[hash];
@@ -146,20 +148,19 @@ cache_result cache_add(cache_t cache, void *item, uint32_t item_size) {
     }
   }
 
-  
-  cache_entry entry = cache_entry_new();
+  entry = cache_entry_new();
   if(!entry) {
     return CACHE_MALLOC_ERROR;
   }
 
-  cache_entry_map map_entry = cache_entry_map_new();
+  map_entry = cache_entry_map_new();
   if(!map_entry) {
-    free(entry);
+    ndpi_free(entry);
     return CACHE_MALLOC_ERROR;
   }
 
 
-  entry->item = malloc(item_size);
+  entry->item = ndpi_malloc(item_size);
   memcpy(entry->item, item, item_size);
   entry->item_size = item_size;
 
@@ -203,9 +204,9 @@ cache_result cache_add(cache_t cache, void *item, uint32_t item_size) {
       tail->prev->next = NULL;
       cache->tail = tail->prev;
       
-      free(tail->item);
-      free(tail);
-      free(hash_entry_map);
+      ndpi_free(tail->item);
+      ndpi_free(tail);
+      ndpi_free(hash_entry_map);
     }
   }
 
@@ -213,11 +214,13 @@ cache_result cache_add(cache_t cache, void *item, uint32_t item_size) {
 }
 
 cache_result cache_contains(cache_t cache, void *item, uint32_t item_size) {
+  uint32_t hash;
+
   if(!cache || !item || !item_size) {
     return CACHE_INVALID_INPUT;
   }
 
-  uint32_t hash = HASH_FUNCTION(item, item_size) % cache->max_size;
+  hash = HASH_FUNCTION(item, item_size) % cache->max_size;
 
   if(cache->map[hash]) {
     cache_entry_map hash_entry_map = cache->map[hash];
@@ -237,11 +240,13 @@ cache_result cache_contains(cache_t cache, void *item, uint32_t item_size) {
 }
 
 cache_result cache_remove(cache_t cache, void *item, uint32_t item_size) {
+  uint32_t hash;
+
   if(!cache || !item || !item_size) {
     return CACHE_INVALID_INPUT;
   }
 
-  uint32_t hash = HASH_FUNCTION(item, item_size) % cache->max_size;
+  hash = HASH_FUNCTION(item, item_size) % cache->max_size;
 
   if(cache->map[hash]) {
     cache_entry_map hash_entry_map_prev = NULL;
@@ -256,14 +261,16 @@ cache_result cache_remove(cache_t cache, void *item, uint32_t item_size) {
       hash_entry_map = hash_entry_map->next;
     }
 
-    if(hash_entry_map) {      
+    if(hash_entry_map) {
+      cache_entry entry;
+
       if(hash_entry_map_prev) {
         hash_entry_map_prev->next = hash_entry_map->next;
       } else {
         cache->map[hash] = hash_entry_map->next;
       }
 
-      cache_entry entry = hash_entry_map->entry;
+      entry = hash_entry_map->entry;
 
       if(entry->prev) {
         entry->prev->next = entry->next;
@@ -276,9 +283,9 @@ cache_result cache_remove(cache_t cache, void *item, uint32_t item_size) {
         cache->tail = entry->prev;
       }
 
-      free(entry->item);
-      free(entry);
-      free(hash_entry_map);
+      ndpi_free(entry->item);
+      ndpi_free(entry);
+      ndpi_free(hash_entry_map);
 
       (cache->size)--;
       return CACHE_NO_ERROR;
@@ -289,25 +296,25 @@ cache_result cache_remove(cache_t cache, void *item, uint32_t item_size) {
 }
 
 void cache_free(cache_t cache) {
+  int i;
   if(!cache) {
     return;
   }
 
-  int i;
   for(i = 0; i < cache->max_size; i++) {
     cache_entry_map prev = NULL;
     cache_entry_map curr = cache->map[i];
     while(curr) {
       prev = curr;
       curr = curr->next;
-      free(prev->entry->item);
-      free(prev->entry);
-      free(prev);
+      ndpi_free(prev->entry->item);
+      ndpi_free(prev->entry);
+      ndpi_free(prev);
     }
   }
 
-  free(cache->map);
-  free(cache);
+  ndpi_free(cache->map);
+  ndpi_free(cache);
 
   return;
 }