Docs for gerrit 47419

[lhc/web/wiklou.git] / includes / objectcache / MemcachedClient.php

diff --git a/includes/objectcache/MemcachedClient.php b/includes/objectcache/MemcachedClient.php
index 2342d63..f8ce0d0 100644 (file)
--- a/includes/objectcache/MemcachedClient.php
+++ b/includes/objectcache/MemcachedClient.php
@@ -99,7 +99,6 @@ class MWMemcached {
 
        // }}}
 
-
        /**
         * Command statistics
         *
@@ -908,34 +907,71 @@ class MWMemcached {
         * @access private
         */
        function _load_items( $sock, &$ret, &$casToken = null ) {
+               $results = array();
+
                while ( 1 ) {
                        $decl = $this->_fgets( $sock );
+
                        if( $decl === false ) {
+                               /*
+                                * If nothing can be read, something is wrong because we know exactly when
+                                * to stop reading (right after "END") and we return right after that.
+                                */
                                return false;
-                       } elseif ( $decl == "END" ) {
-                               return true;
                        } elseif ( preg_match( '/^VALUE (\S+) (\d+) (\d+) (\d+)$/', $decl, $match ) ) {
-                               list( $rkey, $flags, $len, $casToken ) = array( $match[1], $match[2], $match[3], $match[4] );
-                               $data = $this->_fread( $sock, $len + 2 );
-                               if ( $data === false ) {
-                                       return false;
-                               }
-                               if ( substr( $data, -2 ) !== "\r\n" ) {
-                                       $this->_handle_error( $sock,
-                                               'line ending missing from data block from $1' );
+                               /*
+                                * Read all data returned. This can be either one or multiple values.
+                                * Save all that data (in an array) to be processed later: we'll first
+                                * want to continue reading until "END" before doing anything else,
+                                * to make sure that we don't leave our client in a state where it's
+                                * output is not yet fully read.
+                                */
+                               $results[] = array(
+                                       $match[1], // rkey
+                                       $match[2], // flags
+                                       $match[3], // len
+                                       $match[4], // casToken
+                                       $this->_fread( $sock, $match[3] + 2 ), // data
+                               );
+                       } elseif ( $decl == "END" ) {
+                               if ( count( $results ) == 0 ) {
                                        return false;
                                }
-                               $data = substr( $data, 0, -2 );
-                               $ret[$rkey] = $data;
 
-                               if ( $this->_have_zlib && $flags & self::COMPRESSED ) {
-                                       $ret[$rkey] = gzuncompress( $ret[$rkey] );
-                               }
+                               /**
+                                * All data has been read, time to process the data and build
+                                * meaningful return values.
+                                */
+                               foreach ( $results as $vars ) {
+                                       list( $rkey, $flags, $len, $casToken, $data ) = $vars;
+
+                                       if ( $data === false || substr( $data, -2 ) !== "\r\n" ) {
+                                               $this->_handle_error( $sock,
+                                                       'line ending missing from data block from $1' );
+                                               return false;
+                                       }
+                                       $data = substr( $data, 0, -2 );
+                                       $ret[$rkey] = $data;
+
+                                       if ( $this->_have_zlib && $flags & self::COMPRESSED ) {
+                                               $ret[$rkey] = gzuncompress( $ret[$rkey] );
+                                       }
 
-                               if ( $flags & self::SERIALIZED ) {
-                                       $ret[$rkey] = unserialize( $ret[$rkey] );
+                                       /*
+                                        * This unserialize is the exact reason that we only want to
+                                        * process data after having read until "END" (instead of doing
+                                        * this right away): "unserialize" can trigger outside code:
+                                        * in the event that $ret[$rkey] is a serialized object,
+                                        * unserializing it will trigger __wakeup() if present. If that
+                                        * function attempted to read from memcached (while we did not
+                                        * yet read "END"), these 2 calls would collide.
+                                        */
+                                       if ( $flags & self::SERIALIZED ) {
+                                               $ret[$rkey] = unserialize( $ret[$rkey] );
+                                       }
                                }
 
+                               return true;
                        } else {
                                $this->_handle_error( $sock, 'Error parsing response from $1' );
                                return false;
@@ -1211,7 +1247,6 @@ class MWMemcached {
        // }}}
 }
 
-
 // }}}
 
 class MemCachedClientforWiki extends MWMemcached {