Changeset 63958

Timestamp:

09/28/2026 01:56:38 AM (17 hours ago)

Author:

peterwilsoncc

Message:

Options, Meta APIs: Ensure meta cache is an array before use.

In get_metadata_raw() and metadata_exists() ensure that cached data is of a valid form (ie, an array) before use. This prevents PHP errors of a third party has set the cache directly using a non array value.

Each of these functions now treat invalid cache forms as a cache miss. Invalid cache entries are deleted in update_meta_cache() if they are not an array.

Props josephscott, jonsurrell, westonruter.
Fixes #66091.

Location:

trunk

Files:

• src/wp-includes/meta.php (modified) (7 diffs)
• tests/phpunit/tests/meta.php (modified) (1 diff)

trunk/src/wp-includes/meta.php

@@ -633 +633 @@
  *
  * @since 5.5.0
+ * @since 7.2.0 A cached value that is not an array is now treated as a cache miss.
  *
  * @param string $meta_type Type of object metadata is for. Accepts 'blog', 'post', 'comment', 'term',
@@ -709 +710 @@
         $meta_cache = wp_cache_get( $object_id, $meta_type . '_meta' );
 
-        if ( ! $meta_cache ) {
+        // A cached value that is not an array is unusable, treat it as a cache miss.
+        if ( ! $meta_cache || ! is_array( $meta_cache ) ) {
                 $meta_cache = update_meta_cache( $meta_type, array( $object_id ) );
                 $meta_cache = $meta_cache[ $object_id ] ?? null;
@@ -793 +795 @@
  *
  * @since 3.3.0
+ * @since 7.2.0 A cached value that is not an array is now treated as a cache miss.
  *
  * @param string $meta_type Type of object metadata is for. Accepts 'blog', 'post', 'comment', 'term',
@@ -818 +821 @@
         $meta_cache = wp_cache_get( $object_id, $meta_type . '_meta' );
 
-        if ( ! $meta_cache ) {
+        // A cached value that is not an array is unusable, treat it as a cache miss.
+        if ( ! $meta_cache || ! is_array( $meta_cache ) ) {
                 $meta_cache = update_meta_cache( $meta_type, array( $object_id ) );
-                $meta_cache = $meta_cache[ $object_id ];
+                $meta_cache = $meta_cache[ $object_id ] ?? null;
         }
 
@@ -1166 +1170 @@
  *
  * @since 2.9.0
+ * @since 7.2.0 A cached value that is not an array is now treated as a cache miss.
  *
  * @global wpdb $wpdb WordPress database abstraction object.
@@ -1220 +1225 @@
         }
 
-        $cache_group    = $meta_type . '_meta';
-        $non_cached_ids = array();
-        $cache          = array();
-        $cache_values   = wp_cache_get_multiple( $object_ids, $cache_group );
+        $cache_group       = $meta_type . '_meta';
+        $non_cached_ids    = array();
+        $invalid_cache_ids = array();
+        $cache             = array();
+        $cache_values      = wp_cache_get_multiple( $object_ids, $cache_group );
 
         foreach ( $cache_values as $id => $cached_object ) {
                 if ( false === $cached_object ) {
                         $non_cached_ids[] = $id;
+                } elseif ( ! is_array( $cached_object ) ) {
+                        // A cached value that is not an array is unusable, treat it as a cache miss.
+                        $non_cached_ids[]    = $id;
+                        $invalid_cache_ids[] = $id;
                 } else {
                         $cache[ $id ] = $cached_object;
                 }
+        }
+
+        /*
+         * Remove unusable cached values so that the regenerated values can be added.
+         * A delete followed by an add is used instead of wp_cache_set_multiple()
+         * so that wp_suspend_cache_addition() is still respected.
+         */
+        if ( ! empty( $invalid_cache_ids ) ) {
+                wp_cache_delete_multiple( $invalid_cache_ids, $cache_group );
         }
 
@@ -1269 +1288 @@
                 $data[ $id ] = $cache[ $id ];
         }
+
         wp_cache_add_multiple( $data, $cache_group );
 

trunk/tests/phpunit/tests/meta.php

@@ -130 +130 @@
                 $this->assertFalse( metadata_exists( 'user', 1234567890, 'meta_key' ) );
                 remove_filter( 'get_user_metadata', '__return_zero' );
+        }
+
+        /**
+         * Non-array values that can not be used as a meta cache entry.
+         *
+         * @return array<string, array{mixed}>
+         */
+        public static function data_non_array_cache_values(): array {
+                return array(
+                        'object'  => array( new stdClass() ),
+                        'string'  => array( 'meta_value' ),
+                        'integer' => array( 1 ),
+                        'float'   => array( 1.5 ),
+                        'true'    => array( true ),
+                );
+        }
+
+        /**
+         * @ticket 66091
+         *
+         * @dataProvider data_non_array_cache_values
+         *
+         * @param mixed $invalid_cached_value Unusable value to place in the meta cache.
+         */
+        public function test_metadata_exists_treats_non_array_cache_value_as_miss( $invalid_cached_value ): void {
+                $this->assertTrue( wp_cache_set( self::$author->ID, $invalid_cached_value, 'user_meta' ), 'The unusable value should be placed in the cache, check test setup.' );
+
+                $this->assertTrue( metadata_exists( 'user', self::$author->ID, 'meta_key' ), 'An existing meta key should be reported as existing.' );
+                $this->assertFalse( metadata_exists( 'user', self::$author->ID, 'foobarbaz' ), 'A missing meta key should be reported as not existing.' );
+                $this->assertIsArray( wp_cache_get( self::$author->ID, 'user_meta' ), 'The unusable cache value should have been replaced.' );
+        }
+
+        /**
+         * @ticket 66091
+         *
+         * @dataProvider data_non_array_cache_values
+         *
+         * @param mixed $invalid_cached_value Unusable value to place in the meta cache.
+         */
+        public function test_get_metadata_treats_non_array_cache_value_as_miss( $invalid_cached_value ): void {
+                $this->assertTrue( wp_cache_set( self::$author->ID, $invalid_cached_value, 'user_meta' ), 'The unusable value should be placed in the cache, check test setup.' );
+
+                $this->assertSame( 'meta_value', get_metadata( 'user', self::$author->ID, 'meta_key', true ), 'The single meta value should be returned.' );
+                $this->assertSame( array( 'meta_value' ), get_metadata( 'user', self::$author->ID, 'meta_key' ), 'The array of meta values should be returned.' );
+                $this->assertIsArray( wp_cache_get( self::$author->ID, 'user_meta' ), 'The unusable cache value should have been replaced.' );
+        }
+
+        /**
+         * @ticket 66091
+         *
+         * @dataProvider data_non_array_cache_values
+         *
+         * @param mixed $invalid_cached_value Unusable value to place in the meta cache.
+         */
+        public function test_get_metadata_with_empty_key_treats_non_array_cache_value_as_miss( $invalid_cached_value ): void {
+                $this->assertTrue( wp_cache_set( self::$author->ID, $invalid_cached_value, 'user_meta' ), 'The unusable value should be placed in the cache, check test setup.' );
+
+                $meta = get_metadata( 'user', self::$author->ID );
+
+                $this->assertIsArray( $meta, 'All meta for the object should be returned as an array.' );
+                $this->assertSame( array( 'meta_value' ), $meta['meta_key'], 'The existing meta key should be included in the returned meta.' );
+        }
+
+        /**
+         * @ticket 66091
+         *
+         * @dataProvider data_non_array_cache_values
+         *
+         * @param mixed $invalid_cached_value Unusable value to place in the meta cache.
+         */
+        public function test_update_meta_cache_replaces_non_array_cache_value( $invalid_cached_value ): void {
+                $this->assertTrue( wp_cache_set( self::$author->ID, $invalid_cached_value, 'user_meta' ), 'The unusable value should be placed in the cache, check test setup.' );
+
+                $meta_cache = update_meta_cache( 'user', array( self::$author->ID ) );
+
+                $this->assertIsArray( $meta_cache );
+                $this->assertArrayHasKey( self::$author->ID, $meta_cache );
+                $this->assertIsArray( $meta_cache[ self::$author->ID ], 'The returned meta cache for the object should be an array.' );
+                $this->assertSame( array( 'meta_value' ), $meta_cache[ self::$author->ID ]['meta_key'], 'The returned meta cache should include the existing meta key.' );
+
+                $cached = wp_cache_get( self::$author->ID, 'user_meta' );
+                $this->assertIsArray( $cached, 'The unusable cache value should have been replaced.' );
+                $this->assertSame( array( 'meta_value' ), $cached['meta_key'], 'The replaced cache value should include the existing meta key.' );
+        }
+
+        /**
+         * @ticket 66091
+         */
+        public function test_update_meta_cache_replaces_non_array_cache_value_for_object_without_meta(): void {
+                $term_id = self::factory()->term->create();
+
+                $this->assertTrue( wp_cache_set( $term_id, new stdClass(), 'term_meta' ), 'The unusable value should be placed in the cache, check test setup.' );
+
+                $meta_cache = update_meta_cache( 'term', array( $term_id ) );
+                $this->assertIsArray( $meta_cache );
+                $this->assertArrayHasKey( $term_id, $meta_cache );
+
+                $this->assertSame( array(), $meta_cache[ $term_id ], 'The returned meta cache for an object without meta should be an empty array.' );
+                $this->assertSame( array(), wp_cache_get( $term_id, 'term_meta' ), 'The unusable cache value should have been replaced with an empty array.' );
+        }
+
+        /**
+         * @ticket 66091
+         */
+        public function test_update_meta_cache_removes_non_array_cache_value_while_cache_addition_is_suspended(): void {
+                $this->assertTrue( wp_cache_set( self::$author->ID, new stdClass(), 'user_meta' ), 'The unusable value should be placed in the cache, check test setup.' );
+
+                wp_suspend_cache_addition( true );
+                $meta_cache = update_meta_cache( 'user', array( self::$author->ID ) );
+                wp_suspend_cache_addition( false );
+                $this->assertIsArray( $meta_cache );
+                $this->assertIsArray( $meta_cache[ self::$author->ID ] );
+
+                $this->assertSame( array( 'meta_value' ), $meta_cache[ self::$author->ID ]['meta_key'], 'The meta should still be returned while cache addition is suspended.' );
+                $this->assertFalse( wp_cache_get( self::$author->ID, 'user_meta' ), 'The unusable cache value should be removed but not replaced while cache addition is suspended.' );
         }