* Finish int -> size_t move

* Fix a few cases where operations were performed on un-initalized stack values

7 files changed, 118 insertions, 119 deletions

diff --git a/cluster_library.c b/cluster_library.c
index 8c50d603..1e72e9a9 100644
--- a/cluster_library.c
+++ b/cluster_library.c
@@ -136,8 +136,7 @@ cluster_multibulk_resp_recursive(RedisSock *sock, size_t elements,
         switch(r->type) {
             case TYPE_ERR:
             case TYPE_LINE:
-                //TODO Sean-Der
-                if(redis_sock_gets(sock, buf, sizeof(buf), (size_t *) &r->len) < 0) {
+                if(redis_sock_gets(sock, buf, sizeof(buf), &r->len) < 0) {
                     *err = 1;
                     return;
                 }
@@ -409,7 +408,7 @@ static clusterKeyVal *cluster_dl_add_key(clusterDistList *dl, char *key,
 /* Add a key, returning a pointer to the entry where passed for easy adding
  * of values to match this key */
 int cluster_dist_add_key(redisCluster *c, HashTable *ht, char *key,
-                          int key_len, clusterKeyVal **kv)
+                          size_t key_len, clusterKeyVal **kv)
 {
     int key_free;
     short slot;
@@ -448,7 +447,8 @@ void cluster_dist_add_val(redisCluster *c, clusterKeyVal *kv, zval *z_val
                          TSRMLS_DC)
 {
     char *val;
-    int val_len, val_free;
+    int val_free;
+	size_t val_len;
 
     // Serialize our value
     val_free = redis_serialize(c->flags, z_val, &val, &val_len TSRMLS_CC);
diff --git a/cluster_library.h b/cluster_library.h
index 65d19e3a..9125bc83 100644
--- a/cluster_library.h
+++ b/cluster_library.h
@@ -313,7 +313,7 @@ typedef struct clusterMultiCmd {
 typedef struct clusterReply {
     REDIS_REPLY_TYPE type;         /* Our reply type */
     size_t integer;                /* Integer reply */
-    long long len;                 /* Length of our string */
+    size_t len;                 /* Length of our string */
     char *str;                     /* String reply */
     size_t elements;               /* Count of array elements */
     struct clusterReply **element; /* Array elements */
@@ -329,7 +329,7 @@ void cluster_free_reply(clusterReply *reply, int free_data);
 HashTable *cluster_dist_create();
 void cluster_dist_free(HashTable *ht);
 int cluster_dist_add_key(redisCluster *c, HashTable *ht, char *key,
-    int key_len, clusterKeyVal **kv);
+    size_t key_len, clusterKeyVal **kv);
 void cluster_dist_add_val(redisCluster *c, clusterKeyVal *kv, zval *val
     TSRMLS_DC);
 
diff --git a/library.c b/library.c
index da50de1b..5767c3f9 100644
--- a/library.c
+++ b/library.c
@@ -1977,7 +1977,7 @@ PHP_REDIS_API void redis_free_socket(RedisSock *redis_sock)
 }
 
 PHP_REDIS_API int
-redis_serialize(RedisSock *redis_sock, zval *z, char **val, int *val_len
+redis_serialize(RedisSock *redis_sock, zval *z, char **val, size_t *val_len
                 TSRMLS_DC)
 {
 #if ZEND_MODULE_API_NO >= 20100000
@@ -2049,7 +2049,7 @@ redis_unserialize(RedisSock* redis_sock, const char *val, int val_len,
 {
 
     php_unserialize_data_t var_hash;
-    int ret, rv_free = 0;
+    int ret;
 
     switch(redis_sock->serializer) {
         case REDIS_SERIALIZER_NONE:
@@ -2059,7 +2059,6 @@ redis_unserialize(RedisSock* redis_sock, const char *val, int val_len,
             PHP_VAR_UNSERIALIZE_INIT(var_hash);
             if(!php_var_unserialize(*return_value, (const unsigned char**)&val,
                     (const unsigned char*)val + val_len, &var_hash TSRMLS_CC)) {
-                if(rv_free==1) efree(*return_value);
                 ret = 0;
             } else {
                 ret = 1;
@@ -2074,17 +2073,11 @@ redis_unserialize(RedisSock* redis_sock, const char *val, int val_len,
 
         case REDIS_SERIALIZER_IGBINARY:
 #ifdef HAVE_REDIS_IGBINARY
-            if(!*return_value) {
-				// TODO Sean-Der, heap allocation
-                //MAKE_STD_ZVAL(*return_value);
-                rv_free = 1;
-            }
             if(igbinary_unserialize((const uint8_t *)val, (size_t)val_len,
                                     return_value TSRMLS_CC) == 0)
             {
                 return 1;
             }
-            if (rv_free==1) efree(*return_value);
 #endif
             return 0;
             break;
@@ -2093,7 +2086,7 @@ redis_unserialize(RedisSock* redis_sock, const char *val, int val_len,
 }
 
 PHP_REDIS_API int
-redis_key_prefix(RedisSock *redis_sock, char **key, int *key_len) {
+redis_key_prefix(RedisSock *redis_sock, char **key, size_t *key_len) {
     int ret_len;
     char *ret;
 
diff --git a/library.h b/library.h
index 9c140e54..b7d9d346 100644
--- a/library.h
+++ b/library.h
@@ -60,9 +60,9 @@ PHP_REDIS_API void redis_send_discard(INTERNAL_FUNCTION_PARAMETERS, RedisSock *r
 PHP_REDIS_API int redis_sock_set_err(RedisSock *redis_sock, const char *msg, int msg_len);
 
 PHP_REDIS_API int
-redis_serialize(RedisSock *redis_sock, zval *z, char **val, int *val_len TSRMLS_DC);
+redis_serialize(RedisSock *redis_sock, zval *z, char **val, size_t *val_len TSRMLS_DC);
 PHP_REDIS_API int
-redis_key_prefix(RedisSock *redis_sock, char **key, int *key_len);
+redis_key_prefix(RedisSock *redis_sock, char **key, size_t *key_len);
 
 PHP_REDIS_API int
 redis_unserialize(RedisSock *redis_sock, const char *val, int val_len, zval **return_value TSRMLS_DC);
diff --git a/redis.c b/redis.c
index f26b5694..01f110df 100644
--- a/redis.c
+++ b/redis.c
@@ -991,9 +991,10 @@ PHP_METHOD(Redis, getMultiple)
         zend_hash_move_forward_ex(hash, &ptr))
     {
         char *key;
-        int key_len, key_free;
+        int key_free;
+        size_t key_len;
         zval z_tmp;
-		ZVAL_UNDEF(&z_tmp);
+        ZVAL_UNDEF(&z_tmp);
 
         /* If the key isn't a string, turn it into one */
         if(Z_TYPE_P(z_ele) == IS_STRING) {
@@ -1002,7 +1003,7 @@ PHP_METHOD(Redis, getMultiple)
         } else {
             ZVAL_DUP(&z_tmp, z_ele);
 
-			convert_to_string(&z_tmp);
+            convert_to_string(&z_tmp);
             key = Z_STRVAL(z_tmp);
             key_len = Z_STRLEN(z_tmp);
         }
@@ -1449,8 +1450,7 @@ PHP_REDIS_API void generic_sort_cmd(INTERNAL_FUNCTION_PARAMETERS, char *sort,
     cmd_sizes[2] = 4;
 
     /* Prefix our key if we need to */
-    //TODO Sean-Der
-    key_free = redis_key_prefix(redis_sock, &key, (int *) &key_len);
+    key_free = redis_key_prefix(redis_sock, &key, &key_len);
 
     /* second line, key */
     cmd_sizes[3] = redis_cmd_format(&cmd_lines[3], "$%d", key_len);
@@ -1853,8 +1853,7 @@ generic_mset(INTERNAL_FUNCTION_PARAMETERS, char *kw, ResultCallback fun) {
 
             zend_string *key_zstr;
             char *val, *key;
-            unsigned int key_len;
-            int val_len;
+            size_t val_len, key_len;
             unsigned long idx;
             int type;
             zval *z_value_p;
@@ -1879,10 +1878,10 @@ generic_mset(INTERNAL_FUNCTION_PARAMETERS, char *kw, ResultCallback fun) {
                 key_len = key_zstr->len;
                 key = key_zstr->val;
 
-				// When not an integer key, the length will include the \0
-				if (key_len > 0) {
-					key_len--;
-				}
+                // When not an integer key, the length will include the \0
+                if (key_len > 0) {
+                    key_len--;
+                }
             }
 
             if(step == 0)
@@ -1890,7 +1889,7 @@ generic_mset(INTERNAL_FUNCTION_PARAMETERS, char *kw, ResultCallback fun) {
 
             val_free = redis_serialize(redis_sock, z_value_p, &val, &val_len
                 TSRMLS_CC);
-            key_free = redis_key_prefix(redis_sock, &key, (int*)&key_len);
+            key_free = redis_key_prefix(redis_sock, &key, &key_len);
 
             if(step == 0) { /* counting */
                 cmd_len += 1 + integer_length(key_len) + 2
@@ -2912,7 +2911,8 @@ redis_build_pubsub_cmd(RedisSock *redis_sock, char **ret, PUBSUB_TYPE type,
     HashPosition ptr;
     zval *z_ele;
     char *key;
-    int cmd_len, key_len, key_free;
+    size_t key_len;
+    int cmd_len, key_free;
     smart_string cmd = {0};
 
     if(type == PUBSUB_CHANNELS) {
@@ -2952,9 +2952,10 @@ redis_build_pubsub_cmd(RedisSock *redis_sock, char **ret, PUBSUB_TYPE type,
             zend_hash_move_forward_ex(ht_chan, &ptr))
         {
             char *key;
-            int key_len, key_free;
+            int key_free;
+            size_t key_len;
             zval z_tmp;
-			ZVAL_UNDEF(&z_tmp);
+            ZVAL_UNDEF(&z_tmp);
 
             if(Z_TYPE_P(z_ele) == IS_STRING) {
                 key = Z_STRVAL_P(z_ele);
@@ -3107,7 +3108,8 @@ redis_build_eval_cmd(RedisSock *redis_sock, char **ret, char *keyword,
             {
                 zval z_tmp;
                 char *key, *old_cmd;
-                int key_len, key_free;
+                int key_free;
+                size_t key_len;
 
                 if(Z_TYPE_P(elem) == IS_STRING) {
                     key = Z_STRVAL_P(elem);
@@ -3377,8 +3379,7 @@ PHP_METHOD(Redis, migrate) {
     }
 
     // Prefix our key if we need to, build our command
-    // TODO Sean-Der
-    key_free = redis_key_prefix(redis_sock, &key, (int *) &key_len);
+    key_free = redis_key_prefix(redis_sock, &key,  &key_len);
 
     /* Construct our command */
     if(copy && replace) {
@@ -3740,7 +3741,7 @@ redis_build_scan_cmd(char **cmd, REDIS_SCAN_TYPE type, char *key, int key_len,
                      int iter, char *pattern, int pattern_len, int count)
 {
     char *keyword;
-    int arg_count, cmd_len;
+    int arg_count = 0, cmd_len;
 
     /* Count our arguments +1 for key if it's got one, and + 2 for pattern */
     /* or count given that they each carry keywords with them. */
@@ -3799,7 +3800,7 @@ generic_scan_cmd(INTERNAL_FUNCTION_PARAMETERS, REDIS_SCAN_TYPE type) {
     RedisSock *redis_sock;
     HashTable *hash;
     char *pattern=NULL, *cmd, *key=NULL;
-    size_t key_len, pattern_len;
+    size_t key_len = 0, pattern_len = 0;
     int cmd_len, num_elements, key_free=0;
     long count=0, iter;
 
@@ -3852,9 +3853,8 @@ generic_scan_cmd(INTERNAL_FUNCTION_PARAMETERS, REDIS_SCAN_TYPE type) {
     }
 
     /* Prefix our key if we've got one and we have a prefix set */
-    //TODO Sean-Der
     if(key_len) {
-        key_free = redis_key_prefix(redis_sock, &key, (int *) &key_len);
+        key_free = redis_key_prefix(redis_sock, &key,  &key_len);
     }
 
     /**
diff --git a/redis_cluster.c b/redis_cluster.c
index c16b60c9..f4dc35be 100644
--- a/redis_cluster.c
+++ b/redis_cluster.c
@@ -524,11 +524,13 @@ typedef struct clusterKeyValHT {
     char kbuf[22];
 
     char  *key;
-    int   key_len, key_free;
+	size_t key_len;
+    int    key_free;
     short slot;
 
     char *val;
-    int  val_len, val_free;
+	size_t val_len;
+    int  val_free;
 } clusterKeyValHT;
 
 /* Helper to pull a key/value pair from a HashTable */
@@ -959,8 +961,7 @@ PHP_METHOD(RedisCluster, keys) {
     }
 
     /* Prefix and then build our command */
-	//TODO Sean-Der
-    pat_free = redis_key_prefix(c->flags, &pat, (int *) &pat_len);
+    pat_free = redis_key_prefix(c->flags, &pat, &pat_len);
     cmd_len = redis_cmd_format_static(&cmd, "KEYS", "s", pat, pat_len);
     if(pat_free) efree(pat);
 
@@ -1807,8 +1808,8 @@ static void cluster_eval_cmd(INTERNAL_FUNCTION_PARAMETERS, redisCluster *c,
 {
     redisClusterNode *node=NULL;
     char *lua, *key;
-    int key_free, args_count=0, key_len;
-	size_t lua_len;
+    int key_free, args_count=0;
+	size_t lua_len, key_len;
     zval *z_arr=NULL, *z_ele;
     HashTable *ht_arr;
     HashPosition ptr;
@@ -2208,7 +2209,8 @@ PHP_METHOD(RedisCluster, discard) {
 static short
 cluster_cmd_get_slot(redisCluster *c, zval *z_arg TSRMLS_DC)
 {
-    int key_len, key_free;
+    int key_free;
+	size_t key_len;
     zval *z_host, *z_port, z_tmp;
     short slot;
     char *key;
@@ -2406,8 +2408,7 @@ static void cluster_kscan_cmd(INTERNAL_FUNCTION_PARAMETERS,
     }
 
     // Apply any key prefix we have, get the slot
-	// TODO Sean-Der
-    key_free = redis_key_prefix(c->flags, &key, (int *) &key_len);
+    key_free = redis_key_prefix(c->flags, &key, &key_len);
     slot = cluster_hash_key(key, key_len);
 
     // If SCAN_RETRY is set, loop until we get a zero iterator or until
diff --git a/redis_commands.c b/redis_commands.c
index 89142ec2..210262ed 100644
--- a/redis_commands.c
+++ b/redis_commands.c
@@ -109,8 +109,8 @@ int redis_key_long_val_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                            void **ctx)
 {
     char *key = NULL, *val=NULL;
-    size_t key_len;
-    int val_len, val_free, key_free;
+    size_t key_len, val_len;
+    int val_free, key_free;
     long expire;
     zval *z_val;
 
@@ -122,8 +122,7 @@ int redis_key_long_val_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
 
     // Serialize value, prefix key
     val_free = redis_serialize(redis_sock, z_val, &val, &val_len TSRMLS_CC);
-    //TODO Sean-Der
-    key_free = redis_key_prefix(redis_sock, &key, (int *) &key_len);
+    key_free = redis_key_prefix(redis_sock, &key, &key_len);
 
     // Construct our command
     *cmd_len = redis_cmd_format_static(cmd, kw, "sls", key, key_len, expire,
@@ -155,7 +154,7 @@ int redis_key_long_str_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     }
 
     // Prefix our key if requested
-    key_free = redis_key_prefix(redis_sock, &key, (int *) &key_len);
+    key_free = redis_key_prefix(redis_sock, &key, &key_len);
 
     // Construct command
     *cmd_len = redis_cmd_format_static(cmd, kw, "sds", key, key_len, (int)lval,
@@ -176,8 +175,8 @@ int redis_kv_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                  void **ctx)
 {
     char *key, *val;
-    size_t key_len;
-    int val_len, key_free, val_free;
+    size_t key_len, val_len;
+    int key_free, val_free;
     zval *z_val;
 
     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz", &key, &key_len,
@@ -187,7 +186,7 @@ int redis_kv_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     }
 
     val_free = redis_serialize(redis_sock, z_val, &val, &val_len TSRMLS_CC);
-    key_free = redis_key_prefix(redis_sock, &key, (int *) &key_len);
+    key_free = redis_key_prefix(redis_sock, &key, &key_len);
 
     // Construct our command
     *cmd_len = redis_cmd_format_static(cmd, kw, "ss", key, key_len, val,
@@ -217,7 +216,7 @@ int redis_key_str_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     }
 
     // Prefix key
-    redis_key_prefix(redis_sock, &key, (int *) &key_len);
+    redis_key_prefix(redis_sock, &key, &key_len);
 
     // Construct command
     *cmd_len = redis_cmd_format_static(cmd, kw, "ss", key, key_len, val,
@@ -245,7 +244,7 @@ int redis_key_str_str_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     }
 
     // Prefix key
-    key_free = redis_key_prefix(redis_sock, &key, (int *) &key_len);
+    key_free = redis_key_prefix(redis_sock, &key, &key_len);
 
     // Construct command
     *cmd_len = redis_cmd_format_static(cmd, kw, "sss", key, key_len, val1,
@@ -277,8 +276,8 @@ int redis_key_key_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     }
 
     // Prefix both keys
-    key1_free = redis_key_prefix(redis_sock, &key1, (int *) &key1_len);
-    key2_free = redis_key_prefix(redis_sock, &key2, (int *) &key2_len);
+    key1_free = redis_key_prefix(redis_sock, &key1, &key1_len);
+    key2_free = redis_key_prefix(redis_sock, &key2, &key2_len);
 
     // If a slot is requested, we can test that they hash the same
     if(slot) {
@@ -323,7 +322,7 @@ int redis_key_long_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     }
 
     // Prefix key
-    key_free = redis_key_prefix(redis_sock, &key, (int *) &key_len);
+    key_free = redis_key_prefix(redis_sock, &key, &key_len);
 
     // Disallow zero length keys (for now)
     if(key_len == 0) {
@@ -358,7 +357,7 @@ int redis_key_long_long_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     }
 
     // Prefix our key
-    key_free = redis_key_prefix(redis_sock, &key, (int *) &key_len);
+    key_free = redis_key_prefix(redis_sock, &key, &key_len);
 
     // Construct command
     *cmd_len = redis_cmd_format_static(cmd, kw, "sll", key, key_len, val1,
@@ -388,7 +387,7 @@ int redis_key_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     }
 
     // Prefix our key
-    key_free = redis_key_prefix(redis_sock, &key, (int *) &key_len);
+    key_free = redis_key_prefix(redis_sock, &key, &key_len);
 
     // Construct our command
     *cmd_len = redis_cmd_format_static(cmd, kw, "s", key, key_len);
@@ -418,7 +417,7 @@ int redis_key_dbl_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     }
 
     // Prefix our key
-    key_free = redis_key_prefix(redis_sock, &key, (int * ) &key_len);
+    key_free = redis_key_prefix(redis_sock, &key, &key_len);
 
     // Construct our command
     *cmd_len = redis_cmd_format_static(cmd, kw, "sf", key, key_len, val);
@@ -486,7 +485,7 @@ int redis_zrange_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
         return FAILURE;
     }
 
-    key_free = redis_key_prefix(redis_sock, &key, (int *) &key_len);
+    key_free = redis_key_prefix(redis_sock, &key, &key_len);
     if(ws) {
         *cmd_len = redis_cmd_format_static(cmd, kw, "sdds", key, key_len, start,
             end, "WITHSCORES", sizeof("WITHSCORES")-1);
@@ -549,7 +548,7 @@ int redis_zrangebyscore_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     }
 
     // Prefix our key, set slot
-    key_free = redis_key_prefix(redis_sock, &key, (int *) &key_len);
+    key_free = redis_key_prefix(redis_sock, &key, &key_len);
     CMD_SET_SLOT(slot,key,key_len);
 
     // Construct our command
@@ -640,7 +639,7 @@ int redis_zinter_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     }
 
     // Prefix key
-    key_free = redis_key_prefix(redis_sock, &key, (int *) &key_len);
+    key_free = redis_key_prefix(redis_sock, &key, &key_len);
 
     // Start building our command
     redis_cmd_init_sstr(&cmdstr, argc, kw, strlen(kw));
@@ -657,7 +656,7 @@ int redis_zinter_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
         zend_hash_move_forward_ex(ht_keys, &ptr))
     {
         char *key;
-        int key_free, key_len;
+        int key_free;
         zval z_tmp;
         ZVAL_UNDEF(&z_tmp);
 
@@ -756,7 +755,8 @@ int redis_subscribe_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     HashPosition ptr;
     smart_string cmdstr = {0};
     subscribeContext *sctx = emalloc(sizeof(subscribeContext));
-    int key_len, key_free;
+    int key_free;
+	size_t key_len;
     char *key;
 
     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "af", &z_arr,
@@ -840,7 +840,7 @@ int redis_unsubscribe_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
         zend_hash_move_forward_ex(ht_arr, &ptr))
     {
         char *key = Z_STRVAL_P(z_chan);
-        int key_len = Z_STRLEN_P(z_chan), key_free;
+        size_t key_len = Z_STRLEN_P(z_chan), key_free;
 
         key_free = redis_key_prefix(redis_sock, &key, &key_len);
         redis_cmd_append_sstr(&cmdstr, key, key_len);
@@ -890,7 +890,7 @@ int redis_zrangebylex_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     }
 
     /* Prefix key */
-    key_free = redis_key_prefix(redis_sock, &key, (int *) &key_len);
+    key_free = redis_key_prefix(redis_sock, &key, &key_len);
 
     /* Construct command */
     if(argc == 3) {
@@ -936,7 +936,7 @@ int redis_gen_zlex_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     }
 
     /* Prefix key if we need to */
-    key_free = redis_key_prefix(redis_sock, &key, (int *) &key_len);
+    key_free = redis_key_prefix(redis_sock, &key, &key_len);
 
     /* Construct command */
     *cmd_len = redis_cmd_format_static(cmd, kw, "sss", key, key_len, min,
@@ -960,8 +960,8 @@ int redis_key_varval_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     zval *z_args;
     smart_string cmdstr = {0};
     char *arg;
-    int arg_free, arg_len, i;
-    int argc = ZEND_NUM_ARGS();
+    int arg_free, i, argc = ZEND_NUM_ARGS();
+	size_t arg_len;
 
     // We at least need a key and one value
     if(argc < 2) {
@@ -1018,8 +1018,8 @@ int redis_key_arr_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     HashTable *ht_arr;
     HashPosition pos;
     smart_string cmdstr = {0};
-    int val_len, key_free, val_free, argc = 1;
-    size_t key_len;
+    int key_free, val_free, argc = 1;
+    size_t key_len, val_len;
     char *key, *val;
 
     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sa", &key, &key_len,
@@ -1035,7 +1035,7 @@ int redis_key_arr_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     redis_cmd_init_sstr(&cmdstr, argc, kw, strlen(kw));
 
     /* Prefix if required and append the key name */
-    key_free = redis_key_prefix(redis_sock, &key, (int *) &key_len);
+    key_free = redis_key_prefix(redis_sock, &key, &key_len);
     redis_cmd_append_sstr(&cmdstr, key, key_len);
     CMD_SET_SLOT(slot, key, key_len);
     if (key_free) efree(key);
@@ -1066,7 +1066,8 @@ static int gen_varkey_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     zval *z_args, *z_ele;
     HashTable *ht_arr;
     char *key;
-    int key_free, key_len, i, tail;
+    int key_free, i, tail;
+	size_t key_len;
     int single_array = 0, argc = ZEND_NUM_ARGS();
     smart_string cmdstr = {0};
     long timeout;
@@ -1195,8 +1196,8 @@ int redis_set_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
 {
     zval *z_value, *z_opts=NULL;
     char *key = NULL, *val = NULL, *exp_type = NULL, *set_type = NULL;
-    int val_len, key_free, val_free;
-    size_t key_len;
+    int key_free, val_free;
+    size_t key_len, val_len;
     long expire = -1;
 
     // Make sure the function is being called correctly
@@ -1216,7 +1217,7 @@ int redis_set_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
 
     // Serialize and key prefix if required
     val_free = redis_serialize(redis_sock, z_value, &val, &val_len TSRMLS_CC);
-    key_free = redis_key_prefix(redis_sock, &key, (int *) &key_len);
+    key_free = redis_key_prefix(redis_sock, &key, &key_len);
 
     // Check for an options array
     if(z_opts && Z_TYPE_P(z_opts) == IS_ARRAY) {
@@ -1309,8 +1310,8 @@ int redis_brpoplpush_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     }
 
     // Key prefixing
-    key1_free = redis_key_prefix(redis_sock, &key1, (int *) &key1_len);
-    key2_free = redis_key_prefix(redis_sock, &key2, (int *) &key2_len);
+    key1_free = redis_key_prefix(redis_sock, &key1,  &key1_len);
+    key2_free = redis_key_prefix(redis_sock, &key2,  &key2_len);
 
     // In cluster mode, verify the slots match
     if(slot) {
@@ -1364,7 +1365,7 @@ redis_atomic_increment(INTERNAL_FUNCTION_PARAMETERS, int type,
     }
 
     /* Prefix the key if required */
-    key_free = redis_key_prefix(redis_sock, &key, (int *) &key_len);
+    key_free = redis_key_prefix(redis_sock, &key,  &key_len);
 
     /* If our value is 1 we use INCR/DECR.  For other values, treat the call as
      * an INCRBY or DECRBY call */
@@ -1424,7 +1425,7 @@ int redis_hincrby_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     }
 
     // Prefix our key if necissary
-    key_free = redis_key_prefix(redis_sock, &key, (int *) &key_len);
+    key_free = redis_key_prefix(redis_sock, &key,  &key_len);
 
     // Construct command
     *cmd_len = redis_cmd_format_static(cmd, "HINCRBY", "ssd", key, key_len, mem,
@@ -1455,7 +1456,7 @@ int redis_hincrbyfloat_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     }
 
     // Prefix key
-    key_free = redis_key_prefix(redis_sock, &key, (int *) &key_len);
+    key_free = redis_key_prefix(redis_sock, &key,  &key_len);
 
     // Construct command
     *cmd_len = redis_cmd_format_static(cmd, "HINCRBYFLOAT", "ssf", key, key_len,
@@ -1499,7 +1500,7 @@ int redis_hmget_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     }
 
     // Prefix our key
-    key_free = redis_key_prefix(redis_sock, &key, (int *) &key_len);
+    key_free = redis_key_prefix(redis_sock, &key,  &key_len);
 
     // Allocate memory for mems+1 so we can have a sentinel
 	z_mems = (zval *) safe_emalloc(sizeof(zval), count + 1, 0);
@@ -1583,7 +1584,7 @@ int redis_hmset_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     }
 
     // Prefix our key
-    key_free = redis_key_prefix(redis_sock, &key, (int *) &key_len);
+    key_free = redis_key_prefix(redis_sock, &key,  &key_len);
 
     // Grab our array as a HashTable
     ht_vals = Z_ARRVAL_P(z_arr);
@@ -1599,7 +1600,8 @@ int redis_hmset_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     {
         char *mem, *val, kbuf[40];
         zend_string *mem_zstring;
-        int val_len, val_free;
+        int val_free;
+		size_t val_len;
         unsigned int mem_len;
         zval *z_val;
 
@@ -1664,7 +1666,7 @@ int redis_bitpos_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     }
 
     // Prefix key
-    redis_key_prefix(redis_sock, &key, (int *) &key_len);
+    redis_key_prefix(redis_sock, &key,  &key_len);
 
     // Construct command based on arg count
     if(argc == 2) {
@@ -1690,7 +1692,8 @@ int redis_bitop_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
 {
     zval *z_args;
     char *key;
-    int key_len, i, key_free, argc = ZEND_NUM_ARGS();
+    int i, key_free, argc = ZEND_NUM_ARGS();
+	size_t key_len;
     smart_string cmdstr = {0};
     short kslot;
 
@@ -1761,7 +1764,7 @@ int redis_bitcount_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     }
 
     // Prefix key, construct command
-    key_free = redis_key_prefix(redis_sock, &key, (int *) &key_len);
+    key_free = redis_key_prefix(redis_sock, &key,  &key_len);
     *cmd_len = redis_cmd_format_static(cmd, "BITCOUNT", "sdd", key, key_len,
         (int)start, (int)end);
 
@@ -1785,8 +1788,9 @@ static int redis_gen_pf_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     HashPosition pos;
     smart_string cmdstr = {0};
     char *mem, *key;
-    int key_len, key_free;
-    int mem_len, mem_free, argc=1;
+    int key_free;
+    int mem_free, argc=1;
+	size_t key_len, mem_len;
 
     // Parse arguments
     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sa", &key, &key_len,
@@ -1821,6 +1825,7 @@ static int redis_gen_pf_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
         zend_hash_move_forward_ex(ht_arr, &pos))
     {
         zval z_tmp;
+		ZVAL_UNDEF(&z_tmp);
 
         // Prefix keys, serialize values
         if(is_keys) {
@@ -1909,7 +1914,8 @@ int redis_pfcount_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     HashTable *ht_keys;
     HashPosition ptr;
     smart_string cmdstr = {0};
-    int num_keys, key_len, key_free;
+    int num_keys, key_free;
+	size_t key_len;
     char *key;
     short kslot=-1;
 
@@ -2058,7 +2064,7 @@ int redis_setbit_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
         return FAILURE;
     }
 
-    key_free = redis_key_prefix(redis_sock, &key, (int *) &key_len);
+    key_free = redis_key_prefix(redis_sock, &key,  &key_len);
     *cmd_len = redis_cmd_format_static(cmd, "SETBIT", "sld", key, key_len,
         offset, (int)val);
 
@@ -2075,7 +2081,7 @@ int redis_linsert_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
 {
     char *key, *pivot, *pos, *val;
     size_t key_len, pos_len;
-    int pivot_len, val_len;
+    size_t pivot_len, val_len;
     int key_free, pivot_free, val_free;
     zval *z_val, *z_pivot;
 
@@ -2093,7 +2099,7 @@ int redis_linsert_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     }
 
     // Prefix key, serialize value and position
-    key_free = redis_key_prefix(redis_sock, &key, (int *) &key_len);
+    key_free = redis_key_prefix(redis_sock, &key,  &key_len);
     val_free = redis_serialize(redis_sock, z_val, &val, &val_len TSRMLS_CC);
     pivot_free = redis_serialize(redis_sock, z_pivot, &pivot, &pivot_len
         TSRMLS_CC);
@@ -2120,7 +2126,8 @@ int redis_lrem_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
 {
     char *key, *val;
     size_t key_len;
-    int val_len, key_free, val_free;
+    int key_free, val_free;
+	size_t val_len;
     long count = 0;
     zval *z_val;
 
@@ -2131,7 +2138,7 @@ int redis_lrem_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     }
 
     // Prefix key, serialize value
-    key_free = redis_key_prefix(redis_sock, &key, (int *) &key_len);
+    key_free = redis_key_prefix(redis_sock, &key,  &key_len);
     val_free = redis_serialize(redis_sock, z_val, &val, &val_len TSRMLS_CC);
 
     // Construct command
@@ -2153,8 +2160,7 @@ int redis_smove_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                     char **cmd, int *cmd_len, short *slot, void **ctx)
 {
     char *src, *dst, *val;
-    size_t src_len, dst_len;
-    int val_len;
+    size_t src_len, dst_len, val_len;
     int val_free, src_free, dst_free;
     zval *z_val;
 
@@ -2165,8 +2171,8 @@ int redis_smove_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     }
 
     val_free = redis_serialize(redis_sock, z_val, &val, &val_len TSRMLS_CC);
-    src_free = redis_key_prefix(redis_sock, &src, (int *) &src_len);
-    dst_free = redis_key_prefix(redis_sock, &dst, (int *) &dst_len);
+    src_free = redis_key_prefix(redis_sock, &src,  &src_len);
+    dst_free = redis_key_prefix(redis_sock, &dst,  &dst_len);
 
     // Protect against a CROSSSLOT error
     if(slot) {
@@ -2201,8 +2207,7 @@ static int gen_hset_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                         char *kw, char **cmd, int *cmd_len, short *slot)
 {
     char *key, *mem, *val;
-    size_t mem_len, key_len;
-    int val_len;
+    size_t mem_len, key_len, val_len;
     int val_free, key_free;
     zval *z_val;
 
@@ -2214,7 +2219,7 @@ static int gen_hset_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
 
     // Prefix/serialize
     val_free = redis_serialize(redis_sock, z_val, &val, &val_len TSRMLS_CC);
-    key_free = redis_key_prefix(redis_sock, &key, (int *) &key_len);
+    key_free = redis_key_prefix(redis_sock, &key,  &key_len);
 
     // Construct command
     *cmd_len = redis_cmd_format_static(cmd, kw, "sss", key, key_len, mem,
@@ -2264,7 +2269,7 @@ int redis_srandmember_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     }
 
     // Prefix key if requested
-    key_free = redis_key_prefix(redis_sock, &key, (int *) &key_len);
+    key_free = redis_key_prefix(redis_sock, &key,  &key_len);
 
     // Set our have count flag
     *have_count = ZEND_NUM_ARGS() == 2;
@@ -2292,8 +2297,7 @@ int redis_zincrby_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
                       char **cmd, int *cmd_len, short *slot, void **ctx)
 {
     char *key, *mem;
-    size_t key_len;
-    int mem_len;
+    size_t key_len, mem_len;
     int key_free, mem_free;
     double incrby;
     zval *z_val;
@@ -2305,7 +2309,7 @@ int redis_zincrby_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     }
 
     // Prefix key, serialize
-    key_free = redis_key_prefix(redis_sock, &key, (int *) &key_len);
+    key_free = redis_key_prefix(redis_sock, &key,  &key_len);
     mem_free = redis_serialize(redis_sock, z_val, &mem, &mem_len TSRMLS_CC);
 
     *cmd_len = redis_cmd_format_static(cmd, "ZINCRBY", "sfs", key, key_len,
@@ -2342,7 +2346,7 @@ int redis_sort_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     *using_store = 0;
 
     // Handle key prefixing
-    key_free = redis_key_prefix(redis_sock, &key, (int *) &key_len);
+    key_free = redis_key_prefix(redis_sock, &key,  &key_len);
 
     // If we don't have an options array, the command is quite simple
     if(!z_opts || zend_hash_num_elements(Z_ARRVAL_P(z_opts)) == 0) {
@@ -2561,8 +2565,8 @@ int redis_hdel_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     zval *z_args;
     smart_string cmdstr = {0};
     char *arg;
-    int arg_free, arg_len, i;
-    int argc = ZEND_NUM_ARGS();
+    int arg_free, i, argc = ZEND_NUM_ARGS();
+	size_t arg_len;
 
     // We need at least KEY and one member
     if(argc < 2) {
@@ -2615,7 +2619,8 @@ int redis_zadd_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
 {
     zval *z_args;
     char *key, *val;
-    int key_len, key_free, val_len, val_free;
+	size_t key_len, val_len;
+    int key_free, val_free;
     int argc = ZEND_NUM_ARGS(), i;
     smart_string cmdstr = {0};
 
@@ -2686,7 +2691,7 @@ int redis_object_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     }
 
     // Prefix our key
-    key_free = redis_key_prefix(redis_sock, &key, (int *) &key_len);
+    key_free = redis_key_prefix(redis_sock, &key,  &key_len);
 
     // Format our command
     *cmd_len = redis_cmd_format_static(cmd, "OBJECT", "ss", subcmd, subcmd_len,
@@ -2984,7 +2989,7 @@ void redis_prefix_handler(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock) {
     }
 
     if(redis_sock->prefix != NULL && redis_sock->prefix_len>0) {
-        redis_key_prefix(redis_sock, &key, (int *) &key_len);
+        redis_key_prefix(redis_sock, &key,  &key_len);
         RETURN_STRINGL(key, key_len);
     } else {
         RETURN_STRINGL(key, key_len);
@@ -2996,7 +3001,7 @@ void redis_serialize_handler(INTERNAL_FUNCTION_PARAMETERS,
 {
     zval *z_val;
     char *val;
-    int val_len;
+    size_t val_len;
 
     if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &z_val)==FAILURE) {
         RETURN_FALSE;