Issues in MemcachedPeclBagOStuff.php (master) - Issues in master - wikimedia/mediawiki - Measure and Improve Code Quality continuously with Scrutinizer

Issues (4122)

Security Analysis not enabled

Cross-Site Scripting

Cross-Site Scripting enables an attacker to inject code into the response of a web-request that is viewed by other users. It can for example be used to bypass access controls, or even to take over other users' accounts.

File Exposure

File Exposure allows an attacker to gain access to local files that he should not be able to access. These files can for example include database credentials, or other configuration files.

File Manipulation

File Manipulation enables an attacker to write custom data to files. This potentially leads to injection of arbitrary code on the server.

Object Injection

Object Injection enables an attacker to inject an object into PHP code, and can lead to arbitrary code execution, file exposure, or file manipulation attacks.

Code Injection

Code Injection enables an attacker to execute arbitrary code on the server.

Response Splitting

Response Splitting can be used to send arbitrary responses.

File Inclusion

File Inclusion enables an attacker to inject custom files into PHP's file loading mechanism, either explicitly passed to include, or for example via PHP's auto-loading mechanism.

Command Injection

Command Injection enables an attacker to inject a shell command that is execute with the privileges of the web-server. This can be used to expose sensitive data, or gain access of your server.

SQL Injection

SQL Injection enables an attacker to execute arbitrary SQL code on your database server gaining access to user data, or manipulating user data.

XPath Injection

XPath Injection enables an attacker to modify the parts of XML document that are read. If that XML document is for example used for authentication, this can lead to further vulnerabilities similar to SQL Injection.

LDAP Injection

LDAP Injection enables an attacker to inject LDAP statements potentially granting permission to run unauthorized queries, or modify content inside the LDAP tree.

Header Injection

Other Vulnerability

This category comprises other attack vectors such as manipulating the PHP runtime, loading custom extensions, freezing the runtime, or similar.

Regex Injection

Regex Injection enables an attacker to execute arbitrary code in your PHP process.

XML Injection

XML Injection enables an attacker to read files on your local filesystem including configuration files, or can be abused to freeze your web-server process.

Variable Injection

Variable Injection enables an attacker to overwrite program variables with custom data, and can lead to further vulnerabilities.

Unfortunately, the security analysis is currently not available for your project. If you are a non-commercial open-source project, please contact support to gain access.

libs/objectcache/MemcachedPeclBagOStuff.php (9 issues)

Labels

Bug 9

Severity

Major 9

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?php
/**
 * Object caching using memcached.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 * http://www.gnu.org/copyleft/gpl.html
 *
 * @file
 * @ingroup Cache
 */

/**
 * A wrapper class for the PECL memcached client
 *
 * @ingroup Cache
 */
class MemcachedPeclBagOStuff extends MemcachedBagOStuff {

	/**
	 * Constructor
	 *
	 * Available parameters are:
	 *   - servers:             The list of IP:port combinations holding the memcached servers.
	 *   - persistent:          Whether to use a persistent connection
	 *   - compress_threshold:  The minimum size an object must be before it is compressed
	 *   - timeout:             The read timeout in microseconds
	 *   - connect_timeout:     The connect timeout in seconds
	 *   - retry_timeout:       Time in seconds to wait before retrying a failed connect attempt
	 *   - server_failure_limit:  Limit for server connect failures before it is removed
	 *   - serializer:          May be either "php" or "igbinary". Igbinary produces more compact
	 *                          values, but serialization is much slower unless the php.ini option
	 *                          igbinary.compact_strings is off.
	 *   - use_binary_protocol  Whether to enable the binary protocol (default is ASCII) (boolean)
	 * @param array $params
	 * @throws InvalidArgumentException
	 */
	function __construct( $params ) {
		parent::__construct( $params );
		$params = $this->applyDefaultParams( $params );

		if ( $params['persistent'] ) {
			// The pool ID must be unique to the server/option combination.
			// The Memcached object is essentially shared for each pool ID.
			// We can only reuse a pool ID if we keep the config consistent.
			$this->client = new Memcached( md5( serialize( $params ) ) );
			if ( count( $this->client->getServerList() ) ) {
				$this->logger->debug( __METHOD__ . ": persistent Memcached object already loaded." );
				return; // already initialized; don't add duplicate servers
			}
		} else {
			$this->client = new Memcached;
		}

		if ( $params['use_binary_protocol'] ) {
			$this->client->setOption( Memcached::OPT_BINARY_PROTOCOL, true );
		}

		if ( isset( $params['retry_timeout'] ) ) {
			$this->client->setOption( Memcached::OPT_RETRY_TIMEOUT, $params['retry_timeout'] );
		}

		if ( isset( $params['server_failure_limit'] ) ) {
			$this->client->setOption( Memcached::OPT_SERVER_FAILURE_LIMIT, $params['server_failure_limit'] );
		}

		// The compression threshold is an undocumented php.ini option for some
		// reason. There's probably not much harm in setting it globally, for
		// compatibility with the settings for the PHP client.
		ini_set( 'memcached.compression_threshold', $params['compress_threshold'] );

		// Set timeouts
		$this->client->setOption( Memcached::OPT_CONNECT_TIMEOUT, $params['connect_timeout'] * 1000 );
		$this->client->setOption( Memcached::OPT_SEND_TIMEOUT, $params['timeout'] );
		$this->client->setOption( Memcached::OPT_RECV_TIMEOUT, $params['timeout'] );
		$this->client->setOption( Memcached::OPT_POLL_TIMEOUT, $params['timeout'] / 1000 );

		// Set libketama mode since it's recommended by the documentation and
		// is as good as any. There's no way to configure libmemcached to use
		// hashes identical to the ones currently in use by the PHP client, and
		// even implementing one of the libmemcached hashes in pure PHP for
		// forwards compatibility would require MemcachedClient::get_sock() to be
		// rewritten.
		$this->client->setOption( Memcached::OPT_LIBKETAMA_COMPATIBLE, true );

		// Set the serializer
		switch ( $params['serializer'] ) {
			case 'php':
				$this->client->setOption( Memcached::OPT_SERIALIZER, Memcached::SERIALIZER_PHP );
				break;
			case 'igbinary':
				if ( !Memcached::HAVE_IGBINARY ) {
					throw new InvalidArgumentException(
						__CLASS__ . ': the igbinary extension is not available ' .
						'but igbinary serialization was requested.'
					);
				}
				$this->client->setOption( Memcached::OPT_SERIALIZER, Memcached::SERIALIZER_IGBINARY );
				break;
			default:
				throw new InvalidArgumentException(
					__CLASS__ . ': invalid value for serializer parameter'
				);
		}
		$servers = [];
		foreach ( $params['servers'] as $host ) {
			if ( preg_match( '/^\[(.+)\]:(\d+)$/', $host, $m ) ) {
				$servers[] = [ $m[1], (int)$m[2] ]; // (ip, port)
			} elseif ( preg_match( '/^([^:]+):(\d+)$/', $host, $m ) ) {
				$servers[] = [ $m[1], (int)$m[2] ]; // (ip or path, port)
			} else {
				$servers[] = [ $host, false ]; // (ip or path, port)
			}
		}
		$this->client->addServers( $servers );
	}

	protected function applyDefaultParams( $params ) {
		$params = parent::applyDefaultParams( $params );

		if ( !isset( $params['use_binary_protocol'] ) ) {
			$params['use_binary_protocol'] = false;
		}

		if ( !isset( $params['serializer'] ) ) {
			$params['serializer'] = 'php';
		}

		return $params;
	}

	protected function getWithToken( $key, &$casToken, $flags = 0 ) {
		$this->debugLog( "get($key)" );
		$result = $this->client->get( $this->validateKeyEncoding( $key ), null, $casToken );
		$result = $this->checkResult( $key, $result );
		return $result;
	}

	public function set( $key, $value, $exptime = 0, $flags = 0 ) {
		$this->debugLog( "set($key)" );
		return $this->checkResult( $key, parent::set( $key, $value, $exptime ) );
	}

	protected function cas( $casToken, $key, $value, $exptime = 0 ) {
		$this->debugLog( "cas($key)" );
		return $this->checkResult( $key, parent::cas( $casToken, $key, $value, $exptime ) );
	}

	public function delete( $key ) {
		$this->debugLog( "delete($key)" );
		$result = parent::delete( $key );
		if ( $result === false && $this->client->getResultCode() === Memcached::RES_NOTFOUND ) {
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
			// "Not found" is counted as success in our interface
			return true;
		} else {
			return $this->checkResult( $key, $result );
		}
	}

	public function add( $key, $value, $exptime = 0 ) {
		$this->debugLog( "add($key)" );
		return $this->checkResult( $key, parent::add( $key, $value, $exptime ) );
	}

	public function incr( $key, $value = 1 ) {
		$this->debugLog( "incr($key)" );
		$result = $this->client->increment( $key, $value );
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
		return $this->checkResult( $key, $result );
	}

	public function decr( $key, $value = 1 ) {
		$this->debugLog( "decr($key)" );
		$result = $this->client->decrement( $key, $value );
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
		return $this->checkResult( $key, $result );
	}

	/**
	 * Check the return value from a client method call and take any necessary
	 * action. Returns the value that the wrapper function should return. At
	 * present, the return value is always the same as the return value from
	 * the client, but some day we might find a case where it should be
	 * different.
	 *
	 * @param string $key The key used by the caller, or false if there wasn't one.
	 * @param mixed $result The return value
	 * @return mixed
	 */
	protected function checkResult( $key, $result ) {
		if ( $result !== false ) {
			return $result;
		}
		switch ( $this->client->getResultCode() ) {
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
			case Memcached::RES_SUCCESS:
				break;
			case Memcached::RES_DATA_EXISTS:
			case Memcached::RES_NOTSTORED:
			case Memcached::RES_NOTFOUND:
				$this->debugLog( "result: " . $this->client->getResultMessage() );
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
				break;
			default:
				$msg = $this->client->getResultMessage();
				$logCtx = [];
				if ( $key !== false ) {
					$server = $this->client->getServerByKey( $key );
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
					$logCtx['memcached-server'] = "{$server['host']}:{$server['port']}";
					$logCtx['memcached-key'] = $key;
					$msg = "Memcached error for key \"{memcached-key}\" on server \"{memcached-server}\": $msg";
				} else {
					$msg = "Memcached error: $msg";
				}
				$this->logger->error( $msg, $logCtx );
				$this->setLastError( BagOStuff::ERR_UNEXPECTED );
		}
		return $result;
	}

	public function getMulti( array $keys, $flags = 0 ) {
		$this->debugLog( 'getMulti(' . implode( ', ', $keys ) . ')' );
		foreach ( $keys as $key ) {
			$this->validateKeyEncoding( $key );
		}
		$result = $this->client->getMulti( $keys ) ?: [];
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
		return $this->checkResult( false, $result );
	}

	/**
	 * @param array $data
	 * @param int $exptime
	 * @return bool
	 */
	public function setMulti( array $data, $exptime = 0 ) {
		$this->debugLog( 'setMulti(' . implode( ', ', array_keys( $data ) ) . ')' );
		foreach ( array_keys( $data ) as $key ) {
			$this->validateKeyEncoding( $key );
		}
		$result = $this->client->setMulti( $data, $this->fixExpiry( $exptime ) );
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
		return $this->checkResult( false, $result );
	}

	public function changeTTL( $key, $expiry = 0 ) {
		$this->debugLog( "touch($key)" );
		$result = $this->client->touch( $key, $expiry );
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
		return $this->checkResult( $key, $result );
	}
}


Issues (4122)

Security Analysis not enabled

libs/objectcache/MemcachedPeclBagOStuff.php (9 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

1			<?php
2			/**
3			* Object caching using memcached.
4			*
5			* This program is free software; you can redistribute it and/or modify
6			* it under the terms of the GNU General Public License as published by
7			* the Free Software Foundation; either version 2 of the License, or
8			* (at your option) any later version.
9			*
10			* This program is distributed in the hope that it will be useful,
11			* but WITHOUT ANY WARRANTY; without even the implied warranty of
12			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13			* GNU General Public License for more details.
14			*
15			* You should have received a copy of the GNU General Public License along
16			* with this program; if not, write to the Free Software Foundation, Inc.,
17			* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18			* http://www.gnu.org/copyleft/gpl.html
19			*
20			* @file
21			* @ingroup Cache
22			*/
23
24			/**
25			* A wrapper class for the PECL memcached client
26			*
27			* @ingroup Cache
28			*/
29			class MemcachedPeclBagOStuff extends MemcachedBagOStuff {
30
31			/**
32			* Constructor
33			*
34			* Available parameters are:
35			* - servers: The list of IP:port combinations holding the memcached servers.
36			* - persistent: Whether to use a persistent connection
37			* - compress_threshold: The minimum size an object must be before it is compressed
38			* - timeout: The read timeout in microseconds
39			* - connect_timeout: The connect timeout in seconds
40			* - retry_timeout: Time in seconds to wait before retrying a failed connect attempt
41			* - server_failure_limit: Limit for server connect failures before it is removed
42			* - serializer: May be either "php" or "igbinary". Igbinary produces more compact
43			* values, but serialization is much slower unless the php.ini option
44			* igbinary.compact_strings is off.
45			* - use_binary_protocol Whether to enable the binary protocol (default is ASCII) (boolean)
46			* @param array $params
47			* @throws InvalidArgumentException
48			*/
49			function __construct( $params ) {
50			parent::__construct( $params );
51			$params = $this->applyDefaultParams( $params );
52
53			if ( $params['persistent'] ) {
54			// The pool ID must be unique to the server/option combination.
55			// The Memcached object is essentially shared for each pool ID.
56			// We can only reuse a pool ID if we keep the config consistent.
57			$this->client = new Memcached( md5( serialize( $params ) ) );
58			if ( count( $this->client->getServerList() ) ) {
59			$this->logger->debug( __METHOD__ . ": persistent Memcached object already loaded." );
60			return; // already initialized; don't add duplicate servers
61			}
62			} else {
63			$this->client = new Memcached;
64			}
65
66			if ( $params['use_binary_protocol'] ) {
67			$this->client->setOption( Memcached::OPT_BINARY_PROTOCOL, true );
68			}
69
70			if ( isset( $params['retry_timeout'] ) ) {
71			$this->client->setOption( Memcached::OPT_RETRY_TIMEOUT, $params['retry_timeout'] );
72			}
73
74			if ( isset( $params['server_failure_limit'] ) ) {
75			$this->client->setOption( Memcached::OPT_SERVER_FAILURE_LIMIT, $params['server_failure_limit'] );
76			}
77
78			// The compression threshold is an undocumented php.ini option for some
79			// reason. There's probably not much harm in setting it globally, for
80			// compatibility with the settings for the PHP client.
81			ini_set( 'memcached.compression_threshold', $params['compress_threshold'] );
82
83			// Set timeouts
84			$this->client->setOption( Memcached::OPT_CONNECT_TIMEOUT, $params['connect_timeout'] * 1000 );
85			$this->client->setOption( Memcached::OPT_SEND_TIMEOUT, $params['timeout'] );
86			$this->client->setOption( Memcached::OPT_RECV_TIMEOUT, $params['timeout'] );
87			$this->client->setOption( Memcached::OPT_POLL_TIMEOUT, $params['timeout'] / 1000 );
88
89			// Set libketama mode since it's recommended by the documentation and
90			// is as good as any. There's no way to configure libmemcached to use
91			// hashes identical to the ones currently in use by the PHP client, and
92			// even implementing one of the libmemcached hashes in pure PHP for
93			// forwards compatibility would require MemcachedClient::get_sock() to be
94			// rewritten.
95			$this->client->setOption( Memcached::OPT_LIBKETAMA_COMPATIBLE, true );
96
97			// Set the serializer
98			switch ( $params['serializer'] ) {
99			case 'php':
100			$this->client->setOption( Memcached::OPT_SERIALIZER, Memcached::SERIALIZER_PHP );
101			break;
102			case 'igbinary':
103			if ( !Memcached::HAVE_IGBINARY ) {
104			throw new InvalidArgumentException(
105			__CLASS__ . ': the igbinary extension is not available ' .
106			'but igbinary serialization was requested.'
107			);
108			}
109			$this->client->setOption( Memcached::OPT_SERIALIZER, Memcached::SERIALIZER_IGBINARY );
110			break;
111			default:
112			throw new InvalidArgumentException(
113			__CLASS__ . ': invalid value for serializer parameter'
114			);
115			}
116			$servers = [];
117			foreach ( $params['servers'] as $host ) {
118			if ( preg_match( '/^\[(.+)\]:(\d+)$/', $host, $m ) ) {
119			$servers[] = [ $m[1], (int)$m[2] ]; // (ip, port)
120			} elseif ( preg_match( '/^([^:]+):(\d+)$/', $host, $m ) ) {
121			$servers[] = [ $m[1], (int)$m[2] ]; // (ip or path, port)
122			} else {
123			$servers[] = [ $host, false ]; // (ip or path, port)
124			}
125			}
126			$this->client->addServers( $servers );
127			}
128
129			protected function applyDefaultParams( $params ) {
130			$params = parent::applyDefaultParams( $params );
131
132			if ( !isset( $params['use_binary_protocol'] ) ) {
133			$params['use_binary_protocol'] = false;
134			}
135
136			if ( !isset( $params['serializer'] ) ) {
137			$params['serializer'] = 'php';
138			}
139
140			return $params;
141			}
142
143			protected function getWithToken( $key, &$casToken, $flags = 0 ) {
144			$this->debugLog( "get($key)" );
145			$result = $this->client->get( $this->validateKeyEncoding( $key ), null, $casToken );
146			$result = $this->checkResult( $key, $result );
147			return $result;
148			}
149
150			public function set( $key, $value, $exptime = 0, $flags = 0 ) {
151			$this->debugLog( "set($key)" );
152			return $this->checkResult( $key, parent::set( $key, $value, $exptime ) );
153			}
154
155			protected function cas( $casToken, $key, $value, $exptime = 0 ) {
156			$this->debugLog( "cas($key)" );
157			return $this->checkResult( $key, parent::cas( $casToken, $key, $value, $exptime ) );
158			}
159
160			public function delete( $key ) {
161			$this->debugLog( "delete($key)" );
162			$result = parent::delete( $key );
163			if ( $result === false && $this->client->getResultCode() === Memcached::RES_NOTFOUND ) {
			0 ignored issues – show Bug introduced 2016-02-23 18:13 UTC by Report Bug Copy Issue Report Show Similar Issues like this The method `getResultCode` does only exist in `Memcached`, but not in `MemcachedClient`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
164			// "Not found" is counted as success in our interface
165			return true;
166			} else {
167			return $this->checkResult( $key, $result );
168			}
169			}
170
171			public function add( $key, $value, $exptime = 0 ) {
172			$this->debugLog( "add($key)" );
173			return $this->checkResult( $key, parent::add( $key, $value, $exptime ) );
174			}
175
176			public function incr( $key, $value = 1 ) {
177			$this->debugLog( "incr($key)" );
178			$result = $this->client->increment( $key, $value );
			0 ignored issues – show Bug introduced 2016-02-23 18:13 UTC by Report Bug Copy Issue Report Show Similar Issues like this The method `increment` does only exist in `Memcached`, but not in `MemcachedClient`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
179			return $this->checkResult( $key, $result );
180			}
181
182			public function decr( $key, $value = 1 ) {
183			$this->debugLog( "decr($key)" );
184			$result = $this->client->decrement( $key, $value );
			0 ignored issues – show Bug introduced 2016-02-23 18:13 UTC by Report Bug Copy Issue Report Show Similar Issues like this The method `decrement` does only exist in `Memcached`, but not in `MemcachedClient`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
185			return $this->checkResult( $key, $result );
186			}
187
188			/**
189			* Check the return value from a client method call and take any necessary
190			* action. Returns the value that the wrapper function should return. At
191			* present, the return value is always the same as the return value from
192			* the client, but some day we might find a case where it should be
193			* different.
194			*
195			* @param string $key The key used by the caller, or false if there wasn't one.
196			* @param mixed $result The return value
197			* @return mixed
198			*/
199			protected function checkResult( $key, $result ) {
200			if ( $result !== false ) {
201			return $result;
202			}
203			switch ( $this->client->getResultCode() ) {
			0 ignored issues – show Bug introduced 2016-02-23 18:13 UTC by Report Bug Copy Issue Report Show Similar Issues like this The method `getResultCode` does only exist in `Memcached`, but not in `MemcachedClient`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
204			case Memcached::RES_SUCCESS:
205			break;
206			case Memcached::RES_DATA_EXISTS:
207			case Memcached::RES_NOTSTORED:
208			case Memcached::RES_NOTFOUND:
209			$this->debugLog( "result: " . $this->client->getResultMessage() );
			0 ignored issues – show Bug introduced 2016-02-23 18:13 UTC by Report Bug Copy Issue Report Show Similar Issues like this The method `getResultMessage` does only exist in `Memcached`, but not in `MemcachedClient`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
210			break;
211			default:
212			$msg = $this->client->getResultMessage();
213			$logCtx = [];
214			if ( $key !== false ) {
215			$server = $this->client->getServerByKey( $key );
			0 ignored issues – show Bug introduced 2016-02-23 18:13 UTC by Report Bug Copy Issue Report Show Similar Issues like this The method `getServerByKey` does only exist in `Memcached`, but not in `MemcachedClient`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
216			$logCtx['memcached-server'] = "{$server['host']}:{$server['port']}";
217			$logCtx['memcached-key'] = $key;
218			$msg = "Memcached error for key \"{memcached-key}\" on server \"{memcached-server}\": $msg";
219			} else {
220			$msg = "Memcached error: $msg";
221			}
222			$this->logger->error( $msg, $logCtx );
223			$this->setLastError( BagOStuff::ERR_UNEXPECTED );
224			}
225			return $result;
226			}
227
228			public function getMulti( array $keys, $flags = 0 ) {
229			$this->debugLog( 'getMulti(' . implode( ', ', $keys ) . ')' );
230			foreach ( $keys as $key ) {
231			$this->validateKeyEncoding( $key );
232			}
233			$result = $this->client->getMulti( $keys ) ?: [];
			0 ignored issues – show Bug introduced 2016-02-23 18:13 UTC by Report Bug Copy Issue Report Show Similar Issues like this The method `getMulti` does only exist in `Memcached`, but not in `MemcachedClient`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
234			return $this->checkResult( false, $result );
235			}
236
237			/**
238			* @param array $data
239			* @param int $exptime
240			* @return bool
241			*/
242			public function setMulti( array $data, $exptime = 0 ) {
243			$this->debugLog( 'setMulti(' . implode( ', ', array_keys( $data ) ) . ')' );
244			foreach ( array_keys( $data ) as $key ) {
245			$this->validateKeyEncoding( $key );
246			}
247			$result = $this->client->setMulti( $data, $this->fixExpiry( $exptime ) );
			0 ignored issues – show Bug introduced 2016-02-23 18:13 UTC by Report Bug Copy Issue Report Show Similar Issues like this The method `setMulti` does only exist in `Memcached`, but not in `MemcachedClient`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
248			return $this->checkResult( false, $result );
249			}
250
251			public function changeTTL( $key, $expiry = 0 ) {
252			$this->debugLog( "touch($key)" );
253			$result = $this->client->touch( $key, $expiry );
			0 ignored issues – show Bug introduced 2016-08-12 17:52 UTC by Report Bug Copy Issue Report Show Similar Issues like this The method `touch` does only exist in `MemcachedClient`, but not in `Memcached`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
254			return $this->checkResult( $key, $result );
255			}
256			}
257

wikimedia / mediawiki

Issues (4122)

Security Analysis not enabled

libs/objectcache/MemcachedPeclBagOStuff.php (9 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like