From 34f82ee7c2fd5fbd2785c19be3593ebaec2615f4 Mon Sep 17 00:00:00 2001
From: Luca Deri <deri@ntop.org>
Date: Thu, 16 Oct 2025 21:54:17 +0200
Subject: [PATCH] Added rename

---
 fuzz/stub/RedisStub.cpp | 670 ++++++++++++++++++++--------------------
 1 file changed, 337 insertions(+), 333 deletions(-)

diff --git a/fuzz/stub/RedisStub.cpp b/fuzz/stub/RedisStub.cpp
index b96de0b32a..1ebcd3d1bc 100644
--- a/fuzz/stub/RedisStub.cpp
+++ b/fuzz/stub/RedisStub.cpp
@@ -25,23 +25,23 @@ Redis::Redis(const char *redis_host /* = NULL */,
              const char *redis_password /* = NULL */,
              u_int16_t redis_port /* = 0 */, u_int8_t _redis_db_id /* = 0 */,
              bool giveup_on_failure /* = false */) {
-    this->redisVersion = "RedisStub";
-    this->localToResolve =
-        std::make_unique<StringFifoQueue>(MAX_NUM_QUEUED_ADDRS);
-    this->remoteToResolve =
-        std::make_unique<StringFifoQueue>(MAX_NUM_QUEUED_ADDRS);
+  this->redisVersion = "RedisStub";
+  this->localToResolve =
+    std::make_unique<StringFifoQueue>(MAX_NUM_QUEUED_ADDRS);
+  this->remoteToResolve =
+    std::make_unique<StringFifoQueue>(MAX_NUM_QUEUED_ADDRS);
 
-    memset(&stats, 0, sizeof(stats));
+  memset(&stats, 0, sizeof(stats));
 }
 
 bool Redis::checkList(std::string key) {
-    return (this->store.find(key) == this->store.end() &&
-            this->setStore.find(key) == this->setStore.end());
+  return (this->store.find(key) == this->store.end() &&
+	  this->setStore.find(key) == this->setStore.end());
 }
 
 bool Redis::checkSet(std::string key) {
-    return (this->store.find(key) == this->store.end() &&
-            this->listStore.find(key) == this->listStore.end());
+  return (this->store.find(key) == this->store.end() &&
+	  this->listStore.find(key) == this->listStore.end());
 }
 
 char *Redis::getVersion() { return (char *)this->redisVersion.c_str(); }
@@ -57,514 +57,518 @@ bool Redis::isOperational() { return true; }
 void Redis::setInitializationComplete() {}
 
 int Redis::info(char *rsp, u_int rsp_len) {
-    if (rsp_len == 0) return -1;
+  if (rsp_len == 0) return -1;
 
-    stats.num_other++;
-    if(rsp_len == 0)
-      return -1;
+  stats.num_other++;
+  if(rsp_len == 0)
+    return -1;
     
-    rsp[0] = 0;
-    return 0;
+  rsp[0] = 0;
+  return 0;
 }
 
 u_int Redis::dbsize() {
-    stats.num_other++;
-    return this->store.size();
+  stats.num_other++;
+  return this->store.size();
 }
 
 int Redis::expire(char *key, u_int expire_sec) {
-    stats.num_expire++;
-    return 0;
+  stats.num_expire++;
+  return 0;
 }
 
 int Redis::get(char *key, char *rsp, u_int rsp_len,
                bool cache_it /* = false */) {
-    if (rsp_len == 0) return -1;
+  if (rsp_len == 0) return -1;
 
-    stats.num_get++;
-    std::string strKey(key);
-    if (this->store.find(strKey) == this->store.end() ||
-        snprintf(rsp, rsp_len, "%s", this->store[strKey].c_str()) < 0) {
-        rsp[0] = 0;
-        return -1;
-    }
+  stats.num_get++;
+  std::string strKey(key);
+  if (this->store.find(strKey) == this->store.end() ||
+      snprintf(rsp, rsp_len, "%s", this->store[strKey].c_str()) < 0) {
+    rsp[0] = 0;
+    return -1;
+  }
 
-    return 0;
+  return 0;
 }
 
 int Redis::hashGet(const char *key, const char *member, char *const rsp,
                    u_int rsp_len) {
-    if (rsp_len == 0) return -1;
+  if (rsp_len == 0) return -1;
 
-    std::stringstream ss;
-    ss << key << "@" << member;
-    std::string strKey = ss.str();
-    if (this->store.find(strKey) == this->store.end() ||
-        snprintf(rsp, rsp_len, "%s", this->store[strKey].c_str()) < 0) {
-        rsp[0] = 0;
-        return -1;
-    }
+  std::stringstream ss;
+  ss << key << "@" << member;
+  std::string strKey = ss.str();
+  if (this->store.find(strKey) == this->store.end() ||
+      snprintf(rsp, rsp_len, "%s", this->store[strKey].c_str()) < 0) {
+    rsp[0] = 0;
+    return -1;
+  }
 
-    return 0;
+  return 0;
 }
 
 int Redis::hashDel(const char *key, const char *field) {
-    std::stringstream ss;
-    ss << key << "@" << field;
-    std::string strKey = ss.str();
-    this->store.erase(strKey);
-    return 0;
+  std::stringstream ss;
+  ss << key << "@" << field;
+  std::string strKey = ss.str();
+  this->store.erase(strKey);
+  return 0;
 }
 
 int Redis::hashSet(const char *key, const char *field, const char *value) {
-    std::stringstream ss;
-    ss << key << "@" << field;
-    std::string strKey = ss.str();
-    this->store[strKey] = std::string(value);
-    return 0;
+  std::stringstream ss;
+  ss << key << "@" << field;
+  std::string strKey = ss.str();
+  this->store[strKey] = std::string(value);
+  return 0;
 }
 
 int Redis::set(const char *key, const char *value,
                u_int expire_secs /* = 0 */) {
-    std::string strKey(key);
-    this->store[strKey] = std::string(value);
-    return 0;
+  std::string strKey(key);
+  this->store[strKey] = std::string(value);
+  return 0;
 }
 
 /* setnx = set if not existing */
 int Redis::setnx(const char *key, const char *value,
                  u_int expire_secs /* = 0 */) {
-    std::string strKey(key);
-    if (this->store.find(strKey) != this->store.end()) return -1;
+  std::string strKey(key);
+  if (this->store.find(strKey) != this->store.end()) return -1;
 
-    this->store[strKey] = std::string(value);
-    return 0;
+  this->store[strKey] = std::string(value);
+  return 0;
 }
 
 int Redis::keys(const char *pattern, char ***keys_p) {
-    *keys_p = (char **)malloc(0);
-    return 0;
+  *keys_p = (char **)malloc(0);
+  return 0;
 }
 
 int Redis::hashKeys(const char *pattern, char ***keys_p) {
-    *keys_p = (char **)malloc(0);
-    return 0;
+  *keys_p = (char **)malloc(0);
+  return 0;
 }
 
 int Redis::hashGetAll(const char *key, char ***keys_p, char ***values_p) {
-    *keys_p = NULL;
-    return 0;
+  *keys_p = NULL;
+  return 0;
 }
 
 int Redis::del(char *key) {
-    std::string strKey(key);
-    stats.num_del++;
-    this->store.erase(strKey);
-    return 0;
+  std::string strKey(key);
+  stats.num_del++;
+  this->store.erase(strKey);
+  return 0;
+}
+
+int Redis::rename(char *key, char *new_key) {
+  return 0;
 }
 
 int Redis::pushHostToResolve(char *hostname, bool dont_check_for_existence,
                              bool localHost) {
-    if (!ntop->getPrefs()->is_dns_resolution_enabled()) return 0;
-    if (hostname == NULL) return -1;
+  if (!ntop->getPrefs()->is_dns_resolution_enabled()) return 0;
+  if (hostname == NULL) return -1;
 
-    if (!Utils::shouldResolveHost(hostname)) return -1;
+  if (!Utils::shouldResolveHost(hostname)) return -1;
 
-    std::stringstream ss;
-    ss << DNS_CACHE << "." << hostname;
-    std::string strKey = ss.str();
+  std::stringstream ss;
+  ss << DNS_CACHE << "." << hostname;
+  std::string strKey = ss.str();
 
-    /* Add only if the address has not been resolved yet */
-    if (dont_check_for_existence ||
-        this->store.find(strKey) == this->store.end()) {
-        auto &q = localHost ? localToResolve : remoteToResolve;
-        q->enqueue(hostname);
+  /* Add only if the address has not been resolved yet */
+  if (dont_check_for_existence ||
+      this->store.find(strKey) == this->store.end()) {
+    auto &q = localHost ? localToResolve : remoteToResolve;
+    q->enqueue(hostname);
 
-        return 0;
-    }
+    return 0;
+  }
 
-    return -1;
+  return -1;
 }
 
 int Redis::popHostToResolve(char *hostname, u_int hostname_len) {
-    char *item = localToResolve->dequeue();
-    int rv = -1;
+  char *item = localToResolve->dequeue();
+  int rv = -1;
 
-    if (!item) item = remoteToResolve->dequeue();
+  if (!item) item = remoteToResolve->dequeue();
 
-    if (item) {
-        strncpy(hostname, item, hostname_len);
-        hostname[hostname_len - 1] = 0;
-        free(item);
-        rv = 0;
-    }
+  if (item) {
+    strncpy(hostname, item, hostname_len);
+    hostname[hostname_len - 1] = 0;
+    free(item);
+    rv = 0;
+  }
 
-    return rv;
+  return rv;
 }
 
 int Redis::getAddress(char *numeric_ip, char *rsp, u_int rsp_len,
                       bool queue_if_not_found) {
-    if (rsp_len == 0) return -1;
+  if (rsp_len == 0) return -1;
 
-    int rc;
-    char key[CONST_MAX_LEN_REDIS_KEY];
-    bool already_in_bloom;
+  int rc;
+  char key[CONST_MAX_LEN_REDIS_KEY];
+  bool already_in_bloom;
 
-    rsp[0] = 0;
-    snprintf(key, sizeof(key), "%s.%s", DNS_CACHE, numeric_ip);
+  rsp[0] = 0;
+  snprintf(key, sizeof(key), "%s.%s", DNS_CACHE, numeric_ip);
 
-    if (!ntop->getResolutionBloom()->isSetBit(numeric_ip)) {
-        already_in_bloom = false;
-        rc = -1; /* No way to find it */
-    } else {
-        already_in_bloom = true;
-        rc = this->get(key, rsp, rsp_len);
+  if (!ntop->getResolutionBloom()->isSetBit(numeric_ip)) {
+    already_in_bloom = false;
+    rc = -1; /* No way to find it */
+  } else {
+    already_in_bloom = true;
+    rc = this->get(key, rsp, rsp_len);
+  }
+
+  if (rc != 0) {
+    if (queue_if_not_found) {
+      if (already_in_bloom)
+	ntop->getResolutionBloom()->unsetBit(
+					     numeric_ip); /* Expired key ? */
+
+      this->pushHostToResolve(numeric_ip, true, false);
     }
+  } else {
+    /* We need to extend expire */
+    if (!already_in_bloom)
+      ntop->getResolutionBloom()->setBit(
+					 numeric_ip); /* Previously cached ? */
 
-    if (rc != 0) {
-        if (queue_if_not_found) {
-            if (already_in_bloom)
-                ntop->getResolutionBloom()->unsetBit(
-                    numeric_ip); /* Expired key ? */
+    this->expire(key, DNS_CACHE_DURATION /* expire */);
+  }
 
-            this->pushHostToResolve(numeric_ip, true, false);
-        }
-    } else {
-        /* We need to extend expire */
-        if (!already_in_bloom)
-            ntop->getResolutionBloom()->setBit(
-                numeric_ip); /* Previously cached ? */
-
-        this->expire(key, DNS_CACHE_DURATION /* expire */);
-    }
-
-    return rc;
+  return rc;
 }
 
 int Redis::setResolvedAddress(char *numeric_ip, char *symbolic_ip) {
-    char key[CONST_MAX_LEN_REDIS_KEY], numeric[256], *w, *h;
-    int rc = 0;
+  char key[CONST_MAX_LEN_REDIS_KEY], numeric[256], *w, *h;
+  int rc = 0;
 
-    snprintf(numeric, sizeof(numeric), "%s", numeric_ip);
+  snprintf(numeric, sizeof(numeric), "%s", numeric_ip);
 
-    h = strtok_r(numeric, ";", &w);
+  h = strtok_r(numeric, ";", &w);
 
-    while (h != NULL) {
-        snprintf(key, sizeof(key), "%s.%s", DNS_CACHE, h);
-        ntop->getResolutionBloom()->setBit(h);
-        rc = this->set(key, symbolic_ip, DNS_CACHE_DURATION);
-        h = strtok_r(NULL, ";", &w);
-    }
+  while (h != NULL) {
+    snprintf(key, sizeof(key), "%s.%s", DNS_CACHE, h);
+    ntop->getResolutionBloom()->setBit(h);
+    rc = this->set(key, symbolic_ip, DNS_CACHE_DURATION);
+    h = strtok_r(NULL, ";", &w);
+  }
 
-    return rc;
+  return rc;
 }
 
 int Redis::sadd(const char *set_name, char *item) {
-    std::string strKey(set_name);
-    if (!this->checkSet(strKey)) return -1;
-    if (this->setStore.find(strKey) == this->setStore.end())
-        this->setStore[strKey] = std::set<std::string>();
+  std::string strKey(set_name);
+  if (!this->checkSet(strKey)) return -1;
+  if (this->setStore.find(strKey) == this->setStore.end())
+    this->setStore[strKey] = std::set<std::string>();
 
-    auto result = this->setStore[strKey].insert(std::string(item));
-    return (result.second ? 1 : 0);
+  auto result = this->setStore[strKey].insert(std::string(item));
+  return (result.second ? 1 : 0);
 }
 
 int Redis::srem(const char *set_name, char *item) {
-    std::string strKey(set_name);
-    if (!this->checkSet(strKey)) return -1;
-    if (this->setStore.find(strKey) == this->setStore.end()) return 0;
+  std::string strKey(set_name);
+  if (!this->checkSet(strKey)) return -1;
+  if (this->setStore.find(strKey) == this->setStore.end()) return 0;
 
-    return this->setStore[strKey].erase(std::string(item));
+  return this->setStore[strKey].erase(std::string(item));
 }
 
 int Redis::smembers(lua_State *vm, char *setName) {
-    stats.num_other++;
-    std::string strKey(setName);
-    if (!this->checkSet(strKey)) return -1;
-    if (this->setStore.find(strKey) == this->setStore.end()) return 0;
+  stats.num_other++;
+  std::string strKey(setName);
+  if (!this->checkSet(strKey)) return -1;
+  if (this->setStore.find(strKey) == this->setStore.end()) return 0;
 
-    int k = 0;
-    const auto &values = this->setStore[strKey];
-    for (const auto &val : values) {
-        lua_pushstring(vm, val.c_str());
-        lua_rawseti(vm, -2, k + 1);
-        ++k;
-    }
+  int k = 0;
+  const auto &values = this->setStore[strKey];
+  for (const auto &val : values) {
+    lua_pushstring(vm, val.c_str());
+    lua_rawseti(vm, -2, k + 1);
+    ++k;
+  }
 
-    return 0;
+  return 0;
 }
 
 int Redis::smembers(const char *set_name, char ***members) {
-    std::string strKey(set_name);
-    if (this->setStore.find(strKey) == this->setStore.end()) {
-        *members = NULL;
-        return -1;
-    }
+  std::string strKey(set_name);
+  if (this->setStore.find(strKey) == this->setStore.end()) {
+    *members = NULL;
+    return -1;
+  }
 
-    int k = 0;
-    const auto &values = this->setStore[strKey];
-    if ((*members = (char **)malloc(values.size() * sizeof(char *))) != NULL)
-        for (auto val : values) (*members)[k++] = strdup(val.c_str());
+  int k = 0;
+  const auto &values = this->setStore[strKey];
+  if ((*members = (char **)malloc(values.size() * sizeof(char *))) != NULL)
+    for (auto val : values) (*members)[k++] = strdup(val.c_str());
 
-    return values.size();
+  return values.size();
 }
 
 bool Redis::sismember(const char *set_name, const char *member) {
-    stats.num_other++;
-    std::string strKey(set_name);
-    if (this->setStore.find(strKey) == this->setStore.end()) return false;
+  stats.num_other++;
+  std::string strKey(set_name);
+  if (this->setStore.find(strKey) == this->setStore.end()) return false;
 
-    return (this->setStore[strKey].find(std::string(member)) ==
-            this->setStore[strKey].end());
+  return (this->setStore[strKey].find(std::string(member)) ==
+	  this->setStore[strKey].end());
 }
 
 int Redis::lpush(const char *queue_name, const char *msg, u_int queue_trim_size,
                  bool trace_errors /* = true */) {
-    stats.num_lpush_rpush++;
-    std::string strKey(queue_name);
-    if (!this->checkList(strKey)) return -1;
+  stats.num_lpush_rpush++;
+  std::string strKey(queue_name);
+  if (!this->checkList(strKey)) return -1;
 
-    if (this->listStore.find(strKey) == this->listStore.end())
-        this->listStore[strKey] = std::vector<std::string>();
+  if (this->listStore.find(strKey) == this->listStore.end())
+    this->listStore[strKey] = std::vector<std::string>();
 
-    this->listStore[strKey].insert(this->listStore[strKey].begin(),
-                                   std::string(msg));
+  this->listStore[strKey].insert(this->listStore[strKey].begin(),
+				 std::string(msg));
 
-    if (queue_trim_size > 0) {
-        stats.num_trim++;
-        if (this->ltrim(queue_name, -queue_trim_size, -1) == -1) return -1;
-    }
+  if (queue_trim_size > 0) {
+    stats.num_trim++;
+    if (this->ltrim(queue_name, -queue_trim_size, -1) == -1) return -1;
+  }
 
-    return this->listStore[strKey].size();
+  return this->listStore[strKey].size();
 }
 
 int Redis::rpush(const char *queue_name, const char *msg,
                  u_int queue_trim_size) {
-    stats.num_lpush_rpush++;
-    std::string strKey(queue_name);
-    if (!this->checkList(strKey)) return -1;
+  stats.num_lpush_rpush++;
+  std::string strKey(queue_name);
+  if (!this->checkList(strKey)) return -1;
 
-    if (this->listStore.find(strKey) == this->listStore.end())
-        this->listStore[strKey] = std::vector<std::string>();
+  if (this->listStore.find(strKey) == this->listStore.end())
+    this->listStore[strKey] = std::vector<std::string>();
 
-    this->listStore[strKey].push_back(std::string(msg));
+  this->listStore[strKey].push_back(std::string(msg));
 
-    if (queue_trim_size > 0) {
-        stats.num_trim++;
-        if (this->ltrim(queue_name, -queue_trim_size, -1) == -1) return -1;
-    }
+  if (queue_trim_size > 0) {
+    stats.num_trim++;
+    if (this->ltrim(queue_name, -queue_trim_size, -1) == -1) return -1;
+  }
 
-    return this->listStore[strKey].size();
+  return this->listStore[strKey].size();
 }
 
 int Redis::lindex(const char *queue_name, int idx, char *buf, u_int buf_len) {
-    if (buf_len == 0) return -1;
-    stats.num_other++;
-    std::string strKey(queue_name);
-    if (this->listStore.find(strKey) == this->listStore.end()) {
-        buf[0] = 0;
-        return -1;
-    }
+  if (buf_len == 0) return -1;
+  stats.num_other++;
+  std::string strKey(queue_name);
+  if (this->listStore.find(strKey) == this->listStore.end()) {
+    buf[0] = 0;
+    return -1;
+  }
 
-    const auto &list = this->listStore[strKey];
+  const auto &list = this->listStore[strKey];
 
-    if (idx < 0) idx += (int)list.size();
-    if (idx < 0 || idx >= (int)list.size()) {
-        buf[0] = 0;
-        return -1;
-    }
+  if (idx < 0) idx += (int)list.size();
+  if (idx < 0 || idx >= (int)list.size()) {
+    buf[0] = 0;
+    return -1;
+  }
 
-    snprintf(buf, buf_len, "%s", list[idx].c_str());
+  snprintf(buf, buf_len, "%s", list[idx].c_str());
 
-    return 0;
+  return 0;
 }
 
 int Redis::ltrim(const char *queue_name, int start_idx, int end_idx) {
-    stats.num_other++;
-    std::string strKey(queue_name);
-    if (this->listStore.find(strKey) == this->listStore.end()) return -1;
+  stats.num_other++;
+  std::string strKey(queue_name);
+  if (this->listStore.find(strKey) == this->listStore.end()) return -1;
 
-    auto &list = this->listStore[strKey];
-    if (start_idx < 0) start_idx += list.size();
-    if (end_idx < 0) end_idx += list.size();
-    int k = 0;
-    for (auto it = list.begin(); it != list.end(); ++k) {
-        if (k < start_idx || k > end_idx)
-            list.erase(it);
-        else
-            ++it;
-    }
+  auto &list = this->listStore[strKey];
+  if (start_idx < 0) start_idx += list.size();
+  if (end_idx < 0) end_idx += list.size();
+  int k = 0;
+  for (auto it = list.begin(); it != list.end(); ++k) {
+    if (k < start_idx || k > end_idx)
+      list.erase(it);
+    else
+      ++it;
+  }
 
-    return 0;
+  return 0;
 }
 
 u_int Redis::hstrlen(const char *key, const char *value) {
-    stats.num_other++;
-    std::stringstream ss;
-    ss << key << "@" << value;
-    std::string strKey = ss.str();
-    if (this->store.find(strKey) == this->store.end()) return 0;
+  stats.num_other++;
+  std::stringstream ss;
+  ss << key << "@" << value;
+  std::string strKey = ss.str();
+  if (this->store.find(strKey) == this->store.end()) return 0;
 
-    return this->store[strKey].size();
+  return this->store[strKey].size();
 }
 
 u_int Redis::len(const char *key) {
-    std::string strKey(key);
-    if (this->store.find(strKey) == this->store.end()) return 0;
+  std::string strKey(key);
+  if (this->store.find(strKey) == this->store.end()) return 0;
 
-    return this->store[strKey].size();
+  return this->store[strKey].size();
 }
 
 u_int Redis::llen(const char *queue_name) {
-    stats.num_llen++;
-    std::string strKey(queue_name);
-    if (this->listStore.find(strKey) == this->listStore.end()) return 0;
+  stats.num_llen++;
+  std::string strKey(queue_name);
+  if (this->listStore.find(strKey) == this->listStore.end()) return 0;
 
-    return this->listStore[strKey].size();
+  return this->listStore[strKey].size();
 }
 
 int Redis::lset(const char *queue_name, u_int32_t idx, const char *value) {
-    return -1;
+  return -1;
 }
 
 int Redis::lrem(const char *queue_name, const char *value) {
-    stats.num_other++;
-    std::string strKey(queue_name);
-    if (this->listStore.find(strKey) == this->listStore.end()) return 0;
+  stats.num_other++;
+  std::string strKey(queue_name);
+  if (this->listStore.find(strKey) == this->listStore.end()) return 0;
 
-    for (auto it = this->listStore[strKey].begin();
-         it != this->listStore[strKey].end();) {
-        if (strncmp(it->c_str(), value, it->size()) == 0)
-            this->listStore[strKey].erase(it);
-        else
-            ++it;
-    }
-    return 0;
+  for (auto it = this->listStore[strKey].begin();
+       it != this->listStore[strKey].end();) {
+    if (strncmp(it->c_str(), value, it->size()) == 0)
+      this->listStore[strKey].erase(it);
+    else
+      ++it;
+  }
+  return 0;
 }
 
 int Redis::lrange(const char *list_name, char ***elements, int start_offset,
                   int end_offset) {
-    stats.num_other++;
-    std::string strKey(list_name);
-    if (this->listStore.find(strKey) == this->listStore.end()) return 0;
+  stats.num_other++;
+  std::string strKey(list_name);
+  if (this->listStore.find(strKey) == this->listStore.end()) return 0;
 
-    auto &list = this->listStore[strKey];
-    if (start_offset < 0) start_offset += list.size();
-    if (end_offset < 0) end_offset += list.size();
-    int k = 0;
-    vector<std::string> retList;
-    for (auto it = list.begin(); it != list.end(); ++k, ++it) {
-        if (k >= start_offset && k <= end_offset) retList.push_back(*it);
-    }
+  auto &list = this->listStore[strKey];
+  if (start_offset < 0) start_offset += list.size();
+  if (end_offset < 0) end_offset += list.size();
+  int k = 0;
+  vector<std::string> retList;
+  for (auto it = list.begin(); it != list.end(); ++k, ++it) {
+    if (k >= start_offset && k <= end_offset) retList.push_back(*it);
+  }
 
-    *elements = (char **)malloc(retList.size() * sizeof(char *));
-    for (int i = 0; i < (int)retList.size(); ++i)
-        (*elements)[i] = strdup(retList[i].c_str());
+  *elements = (char **)malloc(retList.size() * sizeof(char *));
+  for (int i = 0; i < (int)retList.size(); ++i)
+    (*elements)[i] = strdup(retList[i].c_str());
 
-    return retList.size();
+  return retList.size();
 }
 
 int Redis::lpop(const char *queue_name, char *buf, u_int buf_len) {
-    stats.num_lpop_rpop++;
-    std::string strKey(queue_name);
-    if (this->listStore.find(strKey) == this->listStore.end()) {
-        buf[0] = 0;
-        return -1;
-    }
+  stats.num_lpop_rpop++;
+  std::string strKey(queue_name);
+  if (this->listStore.find(strKey) == this->listStore.end()) {
+    buf[0] = 0;
+    return -1;
+  }
 
-    if (this->listStore[strKey].size() == 0) {
-        buf[0] = 0;
-        return -1;
-    }
+  if (this->listStore[strKey].size() == 0) {
+    buf[0] = 0;
+    return -1;
+  }
 
-    snprintf(buf, buf_len, "%s", this->listStore[strKey].front().c_str());
-    this->listStore[strKey].erase(this->listStore[strKey].begin());
+  snprintf(buf, buf_len, "%s", this->listStore[strKey].front().c_str());
+  this->listStore[strKey].erase(this->listStore[strKey].begin());
 
-    return 0;
+  return 0;
 }
 
 int Redis::rpop(const char *queue_name, char *buf, u_int buf_len) {
-    stats.num_lpop_rpop++;
-    std::string strKey(queue_name);
-    if (this->listStore.find(strKey) == this->listStore.end()) {
-        buf[0] = 0;
-        return -1;
-    }
+  stats.num_lpop_rpop++;
+  std::string strKey(queue_name);
+  if (this->listStore.find(strKey) == this->listStore.end()) {
+    buf[0] = 0;
+    return -1;
+  }
 
-    if (this->listStore[strKey].size() == 0) {
-        buf[0] = 0;
-        return -1;
-    }
+  if (this->listStore[strKey].size() == 0) {
+    buf[0] = 0;
+    return -1;
+  }
 
-    snprintf(buf, buf_len, "%s", this->listStore[strKey].back().c_str());
-    this->listStore[strKey].pop_back();
+  snprintf(buf, buf_len, "%s", this->listStore[strKey].back().c_str());
+  this->listStore[strKey].pop_back();
 
-    return 0;
+  return 0;
 }
 
 int Redis::incr(const char *key, int amount) {
-    std::string strKey(key);
-    if (this->store.find(strKey) == this->store.end()) return 0;
+  std::string strKey(key);
+  if (this->store.find(strKey) == this->store.end()) return 0;
 
-    const auto &val = this->store[strKey];
-    try {
-        long l = std::stol(val);
-        l += amount;
-        std::stringstream ss;
-        ss << l;
-        this->store[strKey] = ss.str();
-        return l;
-    } catch (std::exception const &e) {
-        return 0;
-    }
+  const auto &val = this->store[strKey];
+  try {
+    long l = std::stol(val);
+    l += amount;
+    std::stringstream ss;
+    ss << l;
+    this->store[strKey] = ss.str();
+    return l;
+  } catch (std::exception const &e) {
+    return 0;
+  }
 }
 
 int Redis::flushDb() {
-    stats.num_other++;
-    this->store.clear();
-    return 0;
+  stats.num_other++;
+  this->store.clear();
+  return 0;
 }
 
 void Redis::flushCache() {}
 
 void Redis::lua(lua_State *vm) {
-    lua_newtable(vm);
+  lua_newtable(vm);
 
-    lua_push_uint64_table_entry(vm, "num_expire", stats.num_expire);
-    lua_push_uint64_table_entry(vm, "num_get", stats.num_get);
-    lua_push_uint64_table_entry(vm, "num_ttl", stats.num_ttl);
-    lua_push_uint64_table_entry(vm, "num_del", stats.num_del);
-    lua_push_uint64_table_entry(vm, "num_hget", stats.num_hget);
-    lua_push_uint64_table_entry(vm, "num_hset", stats.num_hset);
-    lua_push_uint64_table_entry(vm, "num_hdel", stats.num_hdel);
-    lua_push_uint64_table_entry(vm, "num_set", stats.num_set);
-    lua_push_uint64_table_entry(vm, "num_expire", stats.num_expire);
-    lua_push_uint64_table_entry(vm, "num_keys", stats.num_keys);
-    lua_push_uint64_table_entry(vm, "num_hkeys", stats.num_hkeys);
-    lua_push_uint64_table_entry(vm, "num_hgetall", stats.num_hgetall);
-    lua_push_uint64_table_entry(vm, "num_trim", stats.num_trim);
-    lua_push_uint64_table_entry(vm, "num_reconnections",
-                                stats.num_reconnections);
-    lua_push_uint64_table_entry(vm, "num_lpush_rpush", stats.num_lpush_rpush);
-    lua_push_uint64_table_entry(vm, "num_lpop_rpop", stats.num_lpop_rpop);
-    lua_push_uint64_table_entry(vm, "num_llen", stats.num_llen);
-    lua_push_uint64_table_entry(vm, "num_strlen", stats.num_strlen);
-    lua_push_uint64_table_entry(vm, "num_other", stats.num_other);
+  lua_push_uint64_table_entry(vm, "num_expire", stats.num_expire);
+  lua_push_uint64_table_entry(vm, "num_get", stats.num_get);
+  lua_push_uint64_table_entry(vm, "num_ttl", stats.num_ttl);
+  lua_push_uint64_table_entry(vm, "num_del", stats.num_del);
+  lua_push_uint64_table_entry(vm, "num_hget", stats.num_hget);
+  lua_push_uint64_table_entry(vm, "num_hset", stats.num_hset);
+  lua_push_uint64_table_entry(vm, "num_hdel", stats.num_hdel);
+  lua_push_uint64_table_entry(vm, "num_set", stats.num_set);
+  lua_push_uint64_table_entry(vm, "num_expire", stats.num_expire);
+  lua_push_uint64_table_entry(vm, "num_keys", stats.num_keys);
+  lua_push_uint64_table_entry(vm, "num_hkeys", stats.num_hkeys);
+  lua_push_uint64_table_entry(vm, "num_hgetall", stats.num_hgetall);
+  lua_push_uint64_table_entry(vm, "num_trim", stats.num_trim);
+  lua_push_uint64_table_entry(vm, "num_reconnections",
+			      stats.num_reconnections);
+  lua_push_uint64_table_entry(vm, "num_lpush_rpush", stats.num_lpush_rpush);
+  lua_push_uint64_table_entry(vm, "num_lpop_rpop", stats.num_lpop_rpop);
+  lua_push_uint64_table_entry(vm, "num_llen", stats.num_llen);
+  lua_push_uint64_table_entry(vm, "num_strlen", stats.num_strlen);
+  lua_push_uint64_table_entry(vm, "num_other", stats.num_other);
 
-    /* Address resolution */
-    lua_push_uint64_table_entry(vm, "num_resolver_saved_lookups",
-                                stats.num_saved_lookups);
-    lua_push_uint64_table_entry(vm, "num_resolver_get_address",
-                                stats.num_get_address);
-    lua_push_uint64_table_entry(vm, "num_resolver_set_address",
-                                stats.num_set_resolved_address);
+  /* Address resolution */
+  lua_push_uint64_table_entry(vm, "num_resolver_saved_lookups",
+			      stats.num_saved_lookups);
+  lua_push_uint64_table_entry(vm, "num_resolver_get_address",
+			      stats.num_get_address);
+  lua_push_uint64_table_entry(vm, "num_resolver_set_address",
+			      stats.num_set_resolved_address);
 }
 
 char *Redis::dump(char *key) {
-    stats.num_other++;
-    char *ret = (char *)malloc(1);
-    ret[0] = 0;
-    return ret;
+  stats.num_other++;
+  char *ret = (char *)malloc(1);
+  ret[0] = 0;
+  return ret;
 }
 
 int Redis::restore(char *key, char *buf) { return 0; }