Add compression support for PHP Sessions (#2473)

bitactive · web-flow · commit da4ab0a72c66 · 2024-04-08T14:40:15.000-07:00
* Add compression support for PHP Sessions

Previously, compression was available for standard data but not for
session handling. This update enables the compression of PHP sessions,
allowing for more efficient Redis memory usage.

* Move session compress/uncompress logic to helper functions

* Change session_compress_data to always set the out arguments and adjust PS_READ_FUNC
diff --git a/README.md b/README.md
@@ -118,6 +118,16 @@ redis.session.lock_wait_time = 50000
 redis.session.lock_retries = 2000
 ~~~
 
+### Session compression
+
+Following INI variables can be used to configure session compression:
+~~~
+; Should session compression be enabled? Possible values are zstd, lzf, lz4, none. Defaults to: none
+redis.session.compression = zstd
+; What compression level should be used? Compression level depends on used library. For most deployments range 1-9 should be fine. Defaults to: 3
+redis.session.compression_level = 3
+~~~
+
 ## Running the unit tests
 
 phpredis uses a small custom unit test suite for testing functionality of the various classes.  To run tests, simply do the following:
diff --git a/cluster.md b/cluster.md
@@ -206,3 +206,13 @@ To enable, set the following INI variable:
 redis.session.early_refresh = 1
 ```
 Note: This is disabled by default since it may significantly reduce the session lifetime for long-running scripts. Redis server version 6.2+ required.
+
+### Session compression
+
+Following INI variables can be used to configure session compression:
+~~~
+; Should session compression be enabled? Possible values are zstd, lzf, lz4, none. Defaults to: none
+redis.session.compression = zstd
+; What compression level should be used? Compression level depends on used library. For most deployments range 1-9 should be fine. Defaults to: 3
+redis.session.compression_level = 3
+~~~
diff --git a/redis.c b/redis.c
@@ -115,6 +115,8 @@ PHP_INI_BEGIN()
     PHP_INI_ENTRY("redis.session.lock_retries", "100", PHP_INI_ALL, NULL)
     PHP_INI_ENTRY("redis.session.lock_wait_time", "20000", PHP_INI_ALL, NULL)
     PHP_INI_ENTRY("redis.session.early_refresh", "0", PHP_INI_ALL, NULL)
+    PHP_INI_ENTRY("redis.session.compression", "none", PHP_INI_ALL, NULL)
+    PHP_INI_ENTRY("redis.session.compression_level", "3", PHP_INI_ALL, NULL)
 PHP_INI_END()
 
 static const zend_module_dep redis_deps[] = {
diff --git a/redis_session.c b/redis_session.c
@@ -140,6 +140,66 @@ static int session_gc_maxlifetime(void) {
     return value;
 }
 
+/* Retrieve redis.session.compression from php.ini */
+static int session_compression_type(void) {
+#ifdef HAVE_REDIS_LZF
+    if(strncasecmp(INI_STR("redis.session.compression"), "lzf", sizeof("lzf") - 1) == 0) {
+        return REDIS_COMPRESSION_LZF;
+    }
+#endif
+#ifdef HAVE_REDIS_ZSTD
+    if(strncasecmp(INI_STR("redis.session.compression"), "zstd", sizeof("zstd") - 1) == 0) {
+        return REDIS_COMPRESSION_ZSTD;
+    }
+#endif
+#ifdef HAVE_REDIS_LZ4
+    if(strncasecmp(INI_STR("redis.session.compression"), "lz4", sizeof("lz4") - 1) == 0) {
+        return REDIS_COMPRESSION_LZ4;
+    }
+#endif
+    if(strncasecmp(INI_STR("redis.session.compression"), "none", sizeof("none") - 1) == 0) {
+        return REDIS_COMPRESSION_NONE;
+    }
+
+    // E_NOTICE when outside of valid values
+    php_error_docref(NULL, E_NOTICE, "redis.session.compression is outside of valid values, disabling");
+
+    return REDIS_COMPRESSION_NONE;
+}
+
+/* Helper to compress session data */
+static int
+session_compress_data(RedisSock *redis_sock, char *data, size_t len,
+                      char **compressed_data, size_t *compressed_len)
+{
+    if (redis_sock->compression) {
+        if(redis_compress(redis_sock, compressed_data, compressed_len, data, len)) {
+            return 1;
+        }
+    }
+
+    *compressed_data = data;
+    *compressed_len = len;
+
+    return 0;
+}
+
+/* Helper to uncompress session data */
+static int 
+session_uncompress_data(RedisSock *redis_sock, char *data, size_t len,
+                                   char **decompressed_data, size_t *decompressed_len) {
+    if (redis_sock->compression) {
+        if(redis_uncompress(redis_sock, decompressed_data, decompressed_len, data, len)) {
+            return 1;
+        }
+    }
+
+    *decompressed_data = data;
+    *decompressed_len = len;
+
+    return 0;
+}
+
 /* Send a command to Redis.  Returns byte count written to socket (-1 on failure) */
 static int redis_simple_cmd(RedisSock *redis_sock, char *cmd, int cmdlen,
                               char **reply, int *replylen)
@@ -478,6 +538,9 @@ PS_OPEN_FUNC(redis)
                 redis_sock->dbNumber = db;
             }
 
+            redis_sock->compression = session_compression_type();
+            redis_sock->compression_level = INI_INT("redis.session.compression_level");
+
             if (Z_TYPE(context) == IS_ARRAY) {
                 redis_sock_set_stream_context(redis_sock, &context);
             }
@@ -685,10 +748,10 @@ PS_UPDATE_TIMESTAMP_FUNC(redis)
  */
 PS_READ_FUNC(redis)
 {
-    char *resp, *cmd;
-    int resp_len, cmd_len;
+    char *resp, *cmd, *compressed_buf;
+    int resp_len, cmd_len, compressed_free;
     const char *skey = ZSTR_VAL(key);
-    size_t skeylen = ZSTR_LEN(key);
+    size_t skeylen = ZSTR_LEN(key), compressed_len;
 
     if (!skeylen) return FAILURE;
 
@@ -737,8 +800,13 @@ PS_READ_FUNC(redis)
     if (resp_len < 0) {
         *val = ZSTR_EMPTY_ALLOC();
     } else {
-        *val = zend_string_init(resp, resp_len, 0);
+        compressed_free = session_uncompress_data(redis_sock, resp, resp_len, &compressed_buf, &compressed_len);
+        *val = zend_string_init(compressed_buf, compressed_len, 0);
+        if (compressed_free) {
+            efree(compressed_buf); // Free the buffer allocated by redis_uncompress
+        }
     }
+
     efree(resp);
 
     return SUCCESS;
@@ -749,10 +817,10 @@ PS_READ_FUNC(redis)
  */
 PS_WRITE_FUNC(redis)
 {
-    char *cmd, *response;
-    int cmd_len, response_len;
+    char *cmd, *response, *compressed_buf = NULL;
+    int cmd_len, response_len, compressed_free = 0;
     const char *skey = ZSTR_VAL(key), *sval = ZSTR_VAL(val);
-    size_t skeylen = ZSTR_LEN(key), svallen = ZSTR_LEN(val);
+    size_t skeylen = ZSTR_LEN(key), svallen = ZSTR_LEN(val), compressed_len = 0;
 
     if (!skeylen) return FAILURE;
 
@@ -767,8 +835,15 @@ PS_WRITE_FUNC(redis)
     /* send SET command */
     zend_string *session = redis_session_key(redis_sock, skey, skeylen);
 
+    compressed_free = session_compress_data(redis_sock, ZSTR_VAL(val), ZSTR_LEN(val), &compressed_buf, &compressed_len);
+    sval = compressed_buf;
+    svallen = compressed_len;
+    
     cmd_len = REDIS_SPPRINTF(&cmd, "SETEX", "Sds", session, session_gc_maxlifetime(), sval, svallen);
     zend_string_release(session);
+    if (compressed_free) {
+        efree(compressed_buf);
+    }
 
     if (!write_allowed(redis_sock, &pool->lock_status)) {
         php_error_docref(NULL, E_WARNING, "Unable to write session: session lock not held");
@@ -942,6 +1017,9 @@ PS_OPEN_FUNC(rediscluster) {
         c->flags->prefix = CLUSTER_DEFAULT_PREFIX();
     }
 
+    c->flags->compression = session_compression_type();
+    c->flags->compression_level = INI_INT("redis.session.compression_level");
+
     redis_sock_set_auth(c->flags, user, pass);
 
     if ((context = REDIS_HASH_STR_FIND_TYPE_STATIC(ht_conf, "stream", IS_ARRAY)) != NULL) {
@@ -1142,8 +1220,9 @@ PS_UPDATE_TIMESTAMP_FUNC(rediscluster) {
 PS_READ_FUNC(rediscluster) {
     redisCluster *c = PS_GET_MOD_DATA();
     clusterReply *reply;
-    char *cmd, *skey;
-    int cmdlen, skeylen, free_flag;
+    char *cmd, *skey, *compressed_buf;
+    int cmdlen, skeylen, free_flag, compressed_free;
+    size_t compressed_len;
     short slot;
 
     /* Set up our command and slot information */
@@ -1181,7 +1260,11 @@ PS_READ_FUNC(rediscluster) {
     if (reply->str == NULL) {
         *val = ZSTR_EMPTY_ALLOC();
     } else {
-        *val = zend_string_init(reply->str, reply->len, 0);
+        compressed_free = session_uncompress_data(c->flags, reply->str, reply->len, &compressed_buf, &compressed_len);
+        *val = zend_string_init(compressed_buf, compressed_len, 0);
+        if (compressed_free) {
+            efree(compressed_buf); // Free the buffer allocated by redis_uncompress
+        }
     }
 
     free_flag = 1;
@@ -1198,16 +1281,24 @@ PS_READ_FUNC(rediscluster) {
 PS_WRITE_FUNC(rediscluster) {
     redisCluster *c = PS_GET_MOD_DATA();
     clusterReply *reply;
-    char *cmd, *skey;
-    int cmdlen, skeylen;
+    char *cmd, *skey, *compressed_buf = NULL, *sval = ZSTR_VAL(val);
+    int cmdlen, skeylen, compressed_free = 0, svallen = ZSTR_LEN(val);
     short slot;
+    size_t compressed_len = 0;
+
+    compressed_free = session_compress_data(c->flags, sval, svallen, &compressed_buf, &compressed_len);
+    sval = compressed_buf;
+    svallen = compressed_len;
 
     /* Set up command and slot info */
     skey = cluster_session_key(c, ZSTR_VAL(key), ZSTR_LEN(key), &skeylen, &slot);
     cmdlen = redis_spprintf(NULL, NULL, &cmd, "SETEX", "sds", skey,
                             skeylen, session_gc_maxlifetime(),
-                            ZSTR_VAL(val), ZSTR_LEN(val));
+                            sval, svallen);
     efree(skey);
+    if (compressed_free) {
+        efree(compressed_buf);
+    }
 
     /* Attempt to send command */
     c->readonly = 0;
