Issues in BrowscapUpdater.php (master) - Issues in master - browscap/browscap-php - Measure and Improve Code Quality continuously with Scrutinizer

Issues (41)

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.

src/BrowscapUpdater.php (1 issue)

Labels

Severity

Major 1

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
declare(strict_types = 1);

namespace BrowscapPHP;

use BrowscapPHP\Cache\BrowscapCache;
use BrowscapPHP\Exception\ErrorCachedVersionException;
use BrowscapPHP\Exception\ErrorReadingFileException;
use BrowscapPHP\Exception\FetcherException;
use BrowscapPHP\Exception\FileNameMissingException;
use BrowscapPHP\Exception\FileNotFoundException;
use BrowscapPHP\Exception\NoCachedVersionException;
use BrowscapPHP\Exception\NoNewVersionException;
use BrowscapPHP\Helper\Converter;
use BrowscapPHP\Helper\ConverterInterface;
use BrowscapPHP\Helper\Filesystem;
use BrowscapPHP\Helper\IniLoader;
use BrowscapPHP\Helper\IniLoaderInterface;
use GuzzleHttp\Client;
use GuzzleHttp\ClientInterface;
use Psr\Log\LoggerInterface;
use Psr\SimpleCache\CacheInterface;
use Psr\SimpleCache\InvalidArgumentException;

/**
 * Browscap.ini parsing class with caching and update capabilities
 */
final class BrowscapUpdater implements BrowscapUpdaterInterface
{
    public const DEFAULT_TIMEOUT = 5;

    /**
     * The cache instance
     *
     * @var \BrowscapPHP\Cache\BrowscapCacheInterface
     */
    private $cache;

    /**
     * @var \Psr\Log\LoggerInterface
     */
    private $logger;

    /**
     * @var \GuzzleHttp\ClientInterface
     */
    private $client;

    /**
     * Curl connect timeout in seconds
     *
     * @var int
     */
    private $connectTimeout;

    /**
     * Browscap constructor.
     *
     * @param \Psr\SimpleCache\CacheInterface $cache
     * @param LoggerInterface                 $logger
     * @param ClientInterface|null            $client
     * @param int                             $connectTimeout
     */
    public function __construct(
        CacheInterface $cache,
        LoggerInterface $logger,
        ?ClientInterface $client = null,
        int $connectTimeout = self::DEFAULT_TIMEOUT
    ) {
        $this->cache = new BrowscapCache($cache, $logger);
        $this->logger = $logger;

        if (null === $client) {
            $client = new Client();
        }

        $this->client = $client;
        $this->connectTimeout = $connectTimeout;
    }

    /**
     * reads and parses an ini file and writes the results into the cache
     *
     * @param string $iniFile
     *
     * @throws \BrowscapPHP\Exception\FileNameMissingException
     * @throws \BrowscapPHP\Exception\FileNotFoundException
     * @throws \BrowscapPHP\Exception\ErrorReadingFileException
     */
    public function convertFile(string $iniFile) : void
    {
        if (empty($iniFile)) {
            throw new FileNameMissingException('the file name can not be empty');
        }

        if (! is_readable($iniFile)) {
            throw new FileNotFoundException('it was not possible to read the local file ' . $iniFile);
        }

        $iniString = file_get_contents($iniFile);

        if (false === $iniString) {
            throw new ErrorReadingFileException('an error occured while converting the local file into the cache');
        }

        $this->convertString($iniString);
    }

    /**
     * reads and parses an ini string and writes the results into the cache
     *
     * @param string $iniString
     */
    public function convertString(string $iniString) : void
    {
        try {
            $cachedVersion = $this->cache->getItem('browscap.version', false, $success);
        } catch (InvalidArgumentException $e) {
            $this->logger->error(new \InvalidArgumentException('an error occured while reading the data version from the cache', 0, $e));

            return;
        }

        $converter = new Converter($this->logger, $this->cache);

        $this->storeContent($converter, $iniString, $cachedVersion);
    }

    /**
     * fetches a remote file and stores it into a local folder
     *
     * @param string $file The name of the file where to store the remote content
     * @param string $remoteFile The code for the remote file to load
     *
     * @throws \BrowscapPHP\Exception\FetcherException
     * @throws \BrowscapPHP\Helper\Exception
     * @throws \BrowscapPHP\Exception\ErrorCachedVersionException
     */
    public function fetch(string $file, string $remoteFile = IniLoaderInterface::PHP_INI) : void
    {
        try {
            $cachedVersion = $this->checkUpdate();
        } catch (NoNewVersionException $e) {
            return;
        } catch (NoCachedVersionException $e) {
            $cachedVersion = 0;
        }

        $this->logger->debug('started fetching remote file');

        $loader = new IniLoader();
        $loader->setRemoteFilename($remoteFile);

        $uri = $loader->getRemoteIniUrl();

        try {
            /** @var \Psr\Http\Message\ResponseInterface $response */
            $response = $this->client->request('get', $uri, ['connect_timeout' => $this->connectTimeout]);
        } catch (\GuzzleHttp\Exception\GuzzleException $e) {
            throw new FetcherException(
                sprintf(
                    'an error occured while fetching remote data from URI %s',
                    $uri
                ),
                0,
                $e
            );
        }

        if (200 !== $response->getStatusCode()) {
            throw new FetcherException(
                sprintf(
                    'an error occured while fetching remote data from URI %s: StatusCode was %d',
                    $uri,
                    $response->getStatusCode()
                )
            );
        }

        try {
            $content = $response->getBody()->getContents();
        } catch (\Exception $e) {
            throw new FetcherException('an error occured while fetching remote data', 0, $e);
        }

        if (empty($content)) {
            $error = error_get_last();

            if (is_array($error)) {
                throw FetcherException::httpError($uri, $error['message']);
            }

            throw FetcherException::httpError(
                $uri,
                'an error occured while fetching remote data, but no error was raised'
            );
        }

        $this->logger->debug('finished fetching remote file');
        $this->logger->debug('started storing remote file into local file');

        $content = $this->sanitizeContent($content);

        $converter = new Converter($this->logger, $this->cache);
        $iniVersion = $converter->getIniVersion($content);

        if ($iniVersion > $cachedVersion) {
            $fs = new Filesystem();
            $fs->dumpFile($file, $content);
        }

        $this->logger->debug('finished storing remote file into local file');
    }

    /**
     * fetches a remote file, parses it and writes the result into the cache
     * if the local stored information are in the same version as the remote data no actions are
     * taken
     *
     * @param string $remoteFile The code for the remote file to load
     *
     * @throws \BrowscapPHP\Exception\FetcherException
     * @throws \BrowscapPHP\Helper\Exception
     * @throws \BrowscapPHP\Exception\ErrorCachedVersionException
     */
    public function update(string $remoteFile = IniLoaderInterface::PHP_INI) : void
    {
        $this->logger->debug('started fetching remote file');

        try {
            $cachedVersion = $this->checkUpdate();
        } catch (NoNewVersionException $e) {
            return;
        } catch (NoCachedVersionException $e) {
            $cachedVersion = 0;
        }

        $loader = new IniLoader();
        $loader->setRemoteFilename($remoteFile);

        $uri = $loader->getRemoteIniUrl();

        try {
            /** @var \Psr\Http\Message\ResponseInterface $response */
            $response = $this->client->request('get', $uri, ['connect_timeout' => $this->connectTimeout]);
        } catch (\GuzzleHttp\Exception\GuzzleException $e) {
            throw new FetcherException(
                sprintf(
                    'an error occured while fetching remote data from URI %s',
                    $uri
                ),
                0,
                $e
            );
        }

        if (200 !== $response->getStatusCode()) {
            throw new FetcherException(
                sprintf(
                    'an error occured while fetching remote data from URI %s: StatusCode was %d',
                    $uri,
                    $response->getStatusCode()
                )
            );
        }

        try {
            $content = $response->getBody()->getContents();
        } catch (\Exception $e) {
            throw new FetcherException('an error occured while fetching remote data', 0, $e);
        }

        if (empty($content)) {
            $error = error_get_last();

            throw FetcherException::httpError($uri, $error['message'] ?? '');
        }

        $this->logger->debug('finished fetching remote file');
        $this->logger->debug('started updating cache from remote file');

        $converter = new Converter($this->logger, $this->cache);
        $this->storeContent($converter, $content, $cachedVersion);

        $this->logger->debug('finished updating cache from remote file');
    }

    /**
     * checks if an update on a remote location for the local file or the cache
     *
     * @throws \BrowscapPHP\Exception\FetcherException
     * @throws \BrowscapPHP\Exception\NoCachedVersionException
     * @throws \BrowscapPHP\Exception\ErrorCachedVersionException
     * @throws \BrowscapPHP\Exception\NoNewVersionException
     *
     * @return int|null The actual cached version if a newer version is available, null otherwise
     */
    public function checkUpdate() : ?int
    {
        $success = null;

        try {
            $cachedVersion = $this->cache->getItem('browscap.version', false, $success);
        } catch (InvalidArgumentException $e) {
            throw new ErrorCachedVersionException('an error occured while reading the data version from the cache', 0, $e);
        }

        if (! $cachedVersion) {
            // could not load version from cache
            throw new NoCachedVersionException('there is no cached version available, please update from remote');
        }

        $uri = (new IniLoader())->getRemoteVersionUrl();

        try {
            /** @var \Psr\Http\Message\ResponseInterface $response */
            $response = $this->client->request('get', $uri, ['connect_timeout' => $this->connectTimeout]);
        } catch (\GuzzleHttp\Exception\GuzzleException $e) {
            throw new FetcherException(
                sprintf(
                    'an error occured while fetching version data from URI %s',
                    $uri
                ),
                0,
                $e
            );
        }

        if (200 !== $response->getStatusCode()) {
            throw new FetcherException(
                sprintf(
                    'an error occured while fetching version data from URI %s: StatusCode was %d',
                    $uri,
                    $response->getStatusCode()
                )
            );
        }

        try {
            $remoteVersion = $response->getBody()->getContents();
        } catch (\Throwable $e) {
            throw new FetcherException(
                sprintf(
                    'an error occured while fetching version data from URI %s: StatusCode was %d',
                    $uri,
                    $response->getStatusCode()
                ),
                0,
                $e
            );
        }

        if (! $remoteVersion) {
            // could not load remote version
            throw new FetcherException(
                'could not load version from remote location'
            );
        }

        if ($cachedVersion && $remoteVersion && $remoteVersion <= $cachedVersion) {
            throw new NoNewVersionException('there is no newer version available');
        }

        $this->logger->info(
            'a newer version is available, local version: ' . $cachedVersion . ', remote version: ' . $remoteVersion
        );

        return (int) $cachedVersion;
    }

    private function sanitizeContent(string $content) : string
    {
        // replace everything between opening and closing php and asp tags
        $content = preg_replace('/<[?%].*[?%]>/', '', $content);

        // replace opening and closing php and asp tags
        return str_replace(['<?', '<%', '?>', '%>'], '', (string) $content);
    }

    /**
     * reads and parses an ini string and writes the results into the cache
     *
     * @param \BrowscapPHP\Helper\ConverterInterface $converter
     * @param string                                 $content
     * @param int|null                               $cachedVersion
     */
    private function storeContent(ConverterInterface $converter, string $content, ?int $cachedVersion) : void
    {
        $iniString = $this->sanitizeContent($content);
        $iniVersion = $converter->getIniVersion($iniString);

        if (! $cachedVersion || $iniVersion > $cachedVersion) {
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
            $converter->storeVersion();
            $converter->convertString($iniString);
        }
    }
}


1		<?php
2		declare(strict_types = 1);
3
4		namespace BrowscapPHP;
5
6		use BrowscapPHP\Cache\BrowscapCache;
7		use BrowscapPHP\Exception\ErrorCachedVersionException;
8		use BrowscapPHP\Exception\ErrorReadingFileException;
9		use BrowscapPHP\Exception\FetcherException;
10		use BrowscapPHP\Exception\FileNameMissingException;
11		use BrowscapPHP\Exception\FileNotFoundException;
12		use BrowscapPHP\Exception\NoCachedVersionException;
13		use BrowscapPHP\Exception\NoNewVersionException;
14		use BrowscapPHP\Helper\Converter;
15		use BrowscapPHP\Helper\ConverterInterface;
16		use BrowscapPHP\Helper\Filesystem;
17		use BrowscapPHP\Helper\IniLoader;
18		use BrowscapPHP\Helper\IniLoaderInterface;
19		use GuzzleHttp\Client;
20		use GuzzleHttp\ClientInterface;
21		use Psr\Log\LoggerInterface;
22		use Psr\SimpleCache\CacheInterface;
23		use Psr\SimpleCache\InvalidArgumentException;
24
25		/**
26		* Browscap.ini parsing class with caching and update capabilities
27		*/
28		final class BrowscapUpdater implements BrowscapUpdaterInterface
29		{
30		public const DEFAULT_TIMEOUT = 5;
31
32		/**
33		* The cache instance
34		*
35		* @var \BrowscapPHP\Cache\BrowscapCacheInterface
36		*/
37		private $cache;
38
39		/**
40		* @var \Psr\Log\LoggerInterface
41		*/
42		private $logger;
43
44		/**
45		* @var \GuzzleHttp\ClientInterface
46		*/
47		private $client;
48
49		/**
50		* Curl connect timeout in seconds
51		*
52		* @var int
53		*/
54		private $connectTimeout;
55
56		/**
57		* Browscap constructor.
58		*
59	13	* @param \Psr\SimpleCache\CacheInterface $cache
60		* @param LoggerInterface $logger
61		* @param ClientInterface\|null $client
62		* @param int $connectTimeout
63		*/
64		public function __construct(
65	13	CacheInterface $cache,
66	13	LoggerInterface $logger,
67		?ClientInterface $client = null,
68	13	int $connectTimeout = self::DEFAULT_TIMEOUT
69	13	) {
70		$this->cache = new BrowscapCache($cache, $logger);
71		$this->logger = $logger;
72	13
73	13	if (null === $client) {
74	13	$client = new Client();
75		}
76
77		$this->client = $client;
78		$this->connectTimeout = $connectTimeout;
79		}
80
81		/**
82		* reads and parses an ini file and writes the results into the cache
83	3	*
84		* @param string $iniFile
85	3	*
86	1	* @throws \BrowscapPHP\Exception\FileNameMissingException
87		* @throws \BrowscapPHP\Exception\FileNotFoundException
88		* @throws \BrowscapPHP\Exception\ErrorReadingFileException
89	2	*/
90	1	public function convertFile(string $iniFile) : void
91		{
92		if (empty($iniFile)) {
93		throw new FileNameMissingException('the file name can not be empty');
94	1	}
95
96		if (! is_readable($iniFile)) {
97		throw new FileNotFoundException('it was not possible to read the local file ' . $iniFile);
98		}
99	1
100	1	$iniString = file_get_contents($iniFile);
101
102		if (false === $iniString) {
103		throw new ErrorReadingFileException('an error occured while converting the local file into the cache');
104		}
105
106		$this->convertString($iniString);
107	2	}
108
109		/**
110	2	* reads and parses an ini string and writes the results into the cache
111		*
112		* @param string $iniString
113		*/
114		public function convertString(string $iniString) : void
115		{
116		try {
117	2	$cachedVersion = $this->cache->getItem('browscap.version', false, $success);
118		} catch (InvalidArgumentException $e) {
119	2	$this->logger->error(new \InvalidArgumentException('an error occured while reading the data version from the cache', 0, $e));
120	2
121		return;
122		}
123
124		$converter = new Converter($this->logger, $this->cache);
125
126		$this->storeContent($converter, $iniString, $cachedVersion);
127		}
128
129		/**
130		* fetches a remote file and stores it into a local folder
131		*
132	3	* @param string $file The name of the file where to store the remote content
133		* @param string $remoteFile The code for the remote file to load
134		*
135	3	* @throws \BrowscapPHP\Exception\FetcherException
136		* @throws \BrowscapPHP\Helper\Exception
137		* @throws \BrowscapPHP\Exception\ErrorCachedVersionException
138		*/
139	3	public function fetch(string $file, string $remoteFile = IniLoaderInterface::PHP_INI) : void
140	2	{
141		try {
142		$cachedVersion = $this->checkUpdate();
143	2	} catch (NoNewVersionException $e) {
144		return;
145	2	} catch (NoCachedVersionException $e) {
146	2	$cachedVersion = 0;
147		}
148	2
149		$this->logger->debug('started fetching remote file');
150
151	2	$loader = new IniLoader();
152		$loader->setRemoteFilename($remoteFile);
153	2
154		$uri = $loader->getRemoteIniUrl();
155
156		try {
157		/** @var \Psr\Http\Message\ResponseInterface $response */
158		$response = $this->client->request('get', $uri, ['connect_timeout' => $this->connectTimeout]);
159		} catch (\GuzzleHttp\Exception\GuzzleException $e) {
160		throw new FetcherException(
161	2	sprintf(
162		'an error occured while fetching remote data from URI %s',
163		$uri
164		),
165		0,
166	2	$e
167		);
168		}
169
170		if (200 !== $response->getStatusCode()) {
171		throw new FetcherException(
172	2	sprintf(
173	2	'an error occured while fetching remote data from URI %s: StatusCode was %d',
174		$uri,
175	2	$response->getStatusCode()
176		)
177	2	);
178	2	}
179
180	2	try {
181	2	$content = $response->getBody()->getContents();
182	2	} catch (\Exception $e) {
183		throw new FetcherException('an error occured while fetching remote data', 0, $e);
184		}
185	2
186	2	if (empty($content)) {
187		$error = error_get_last();
188
189		if (is_array($error)) {
190		throw FetcherException::httpError($uri, $error['message']);
191		}
192
193		throw FetcherException::httpError(
194		$uri,
195		'an error occured while fetching remote data, but no error was raised'
196		);
197		}
198
199		$this->logger->debug('finished fetching remote file');
200		$this->logger->debug('started storing remote file into local file');
201	2
202		$content = $this->sanitizeContent($content);
203	2
204		$converter = new Converter($this->logger, $this->cache);
205		$iniVersion = $converter->getIniVersion($content);
206	2
207		if ($iniVersion > $cachedVersion) {
208		$fs = new Filesystem();
209		$fs->dumpFile($file, $content);
210	2	}
211	2
212		$this->logger->debug('finished storing remote file into local file');
213		}
214	2
215	2	/**
216		* fetches a remote file, parses it and writes the result into the cache
217	2	* if the local stored information are in the same version as the remote data no actions are
218		* taken
219		*
220	2	* @param string $remoteFile The code for the remote file to load
221		*
222	2	* @throws \BrowscapPHP\Exception\FetcherException
223		* @throws \BrowscapPHP\Helper\Exception
224		* @throws \BrowscapPHP\Exception\ErrorCachedVersionException
225		*/
226		public function update(string $remoteFile = IniLoaderInterface::PHP_INI) : void
227		{
228		$this->logger->debug('started fetching remote file');
229
230	2	try {
231		$cachedVersion = $this->checkUpdate();
232		} catch (NoNewVersionException $e) {
233		return;
234		} catch (NoCachedVersionException $e) {
235	2	$cachedVersion = 0;
236	1	}
237
238	1	$loader = new IniLoader();
239		$loader->setRemoteFilename($remoteFile);
240
241	1	$uri = $loader->getRemoteIniUrl();
242
243	1	try {
244		/** @var \Psr\Http\Message\ResponseInterface $response */
245	1	$response = $this->client->request('get', $uri, ['connect_timeout' => $this->connectTimeout]);
246	1	} catch (\GuzzleHttp\Exception\GuzzleException $e) {
247		throw new FetcherException(
248		sprintf(
249		'an error occured while fetching remote data from URI %s',
250		$uri
251		),
252		0,
253		$e
254		);
255		}
256
257		if (200 !== $response->getStatusCode()) {
258	9	throw new FetcherException(
259		sprintf(
260	9	'an error occured while fetching remote data from URI %s: StatusCode was %d',
261		$uri,
262		$response->getStatusCode()
263	9	)
264		);
265		}
266
267		try {
268	9	$content = $response->getBody()->getContents();
269		} catch (\Exception $e) {
270	5	throw new FetcherException('an error occured while fetching remote data', 0, $e);
271		}
272
273	4	if (empty($content)) {
274		$error = error_get_last();
275
276	4	throw FetcherException::httpError($uri, $error['message'] ?? '');
277		}
278	4
279	1	$this->logger->debug('finished fetching remote file');
280	1	$this->logger->debug('started updating cache from remote file');
281	1
282		$converter = new Converter($this->logger, $this->cache);
283		$this->storeContent($converter, $content, $cachedVersion);
284
285		$this->logger->debug('finished updating cache from remote file');
286	3	}
287	1
288	1	/**
289	1	* checks if an update on a remote location for the local file or the cache
290	1	*
291	1	* @throws \BrowscapPHP\Exception\FetcherException
292	1	* @throws \BrowscapPHP\Exception\NoCachedVersionException
293		* @throws \BrowscapPHP\Exception\ErrorCachedVersionException
294		* @throws \BrowscapPHP\Exception\NoNewVersionException
295		*
296	2	* @return int\|null The actual cached version if a newer version is available, null otherwise
297		*/
298		public function checkUpdate() : ?int
299		{
300		$success = null;
301
302		try {
303	2	$cachedVersion = $this->cache->getItem('browscap.version', false, $success);
304		} catch (InvalidArgumentException $e) {
305	1	throw new ErrorCachedVersionException('an error occured while reading the data version from the cache', 0, $e);
306		}
307	1
308		if (! $cachedVersion) {
309		// could not load version from cache
310	1	throw new NoCachedVersionException('there is no cached version available, please update from remote');
311	1	}
312
313		$uri = (new IniLoader())->getRemoteVersionUrl();
314	1
315		try {
316		/** @var \Psr\Http\Message\ResponseInterface $response */
317	5	$response = $this->client->request('get', $uri, ['connect_timeout' => $this->connectTimeout]);
318		} catch (\GuzzleHttp\Exception\GuzzleException $e) {
319		throw new FetcherException(
320	5	sprintf(
321		'an error occured while fetching version data from URI %s',
322		$uri
323	5	),
324		0,
325		$e
326		);
327		}
328
329		if (200 !== $response->getStatusCode()) {
330		throw new FetcherException(
331		sprintf(
332		'an error occured while fetching version data from URI %s: StatusCode was %d',
333	3	$uri,
334		$response->getStatusCode()
335	3	)
336	3	);
337		}
338	3
339	3	try {
340	3	$remoteVersion = $response->getBody()->getContents();
341		} catch (\Throwable $e) {
342	3	throw new FetcherException(
343		sprintf(
344		'an error occured while fetching version data from URI %s: StatusCode was %d',
345		$uri,
346		$response->getStatusCode()
347		),
348		0,
349		$e
350		);
351		}
352
353		if (! $remoteVersion) {
354		// could not load remote version
355		throw new FetcherException(
356		'could not load version from remote location'
357		);
358		}
359
360		if ($cachedVersion && $remoteVersion && $remoteVersion <= $cachedVersion) {
361		throw new NoNewVersionException('there is no newer version available');
362		}
363
364		$this->logger->info(
365		'a newer version is available, local version: ' . $cachedVersion . ', remote version: ' . $remoteVersion
366		);
367
368		return (int) $cachedVersion;
369		}
370
371		private function sanitizeContent(string $content) : string
372		{
373		// replace everything between opening and closing php and asp tags
374		$content = preg_replace('/<[?%].*[?%]>/', '', $content);
375
376		// replace opening and closing php and asp tags
377		return str_replace(['<?', '<%', '?>', '%>'], '', (string) $content);
378		}
379
380		/**
381		* reads and parses an ini string and writes the results into the cache
382		*
383		* @param \BrowscapPHP\Helper\ConverterInterface $converter
384		* @param string $content
385		* @param int\|null $cachedVersion
386		*/
387		private function storeContent(ConverterInterface $converter, string $content, ?int $cachedVersion) : void
388		{
389		$iniString = $this->sanitizeContent($content);
390		$iniVersion = $converter->getIniVersion($iniString);
391
392		if (! $cachedVersion \|\| $iniVersion > $cachedVersion) {
		0 ignored issues – show Bug Best Practice introduced 2016-05-07 10:33 UTC by Report Bug Copy Issue Report Show Similar Issues like this The expression `$cachedVersion` of type `integer\|null` is loosely compared to `false`; this is ambiguous if the integer can be zero. You might want to explicitly use `=== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `integer` values, zero is a special case, in particular the following results might be unexpected: 0 == false // true 0 == null // true 123 == false // false 123 == null // false // It is often better to use strict comparison 0 === false // false 0 === null // false Loading history...
393		$converter->storeVersion();
394		$converter->convertString($iniString);
395		}
396		}
397		}
398

browscap / browscap-php

Issues (41)

Security Analysis not enabled

src/BrowscapUpdater.php (1 issue)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like