Issues in WebDAVAdapter.php (master) - Issues in master - thephpleague/flysystem-webdav - Measure and Improve Code Quality continuously with Scrutinizer

Issues (3)

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/WebDAVAdapter.php (3 issues)

Labels

Severity

Minor 3

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

namespace League\Flysystem\WebDAV;

use League\Flysystem\Adapter\AbstractAdapter;
use League\Flysystem\Adapter\Polyfill\NotSupportingVisibilityTrait;
use League\Flysystem\Adapter\Polyfill\StreamedCopyTrait;
use League\Flysystem\Adapter\Polyfill\StreamedReadingTrait;
use League\Flysystem\Config;
use League\Flysystem\Util;
use LogicException;
use Sabre\DAV\Client;
use Sabre\DAV\Exception;
use Sabre\DAV\Exception\NotFound;
use Sabre\DAV\Xml\Property\ResourceType;
use Sabre\HTTP\HttpException;

class WebDAVAdapter extends AbstractAdapter
{
    use StreamedReadingTrait;
    use StreamedCopyTrait {
        StreamedCopyTrait::copy as streamedCopy;
    }
    use NotSupportingVisibilityTrait;

    protected static $metadataFields = [
        '{DAV:}displayname',
        '{DAV:}getcontentlength',
        '{DAV:}getcontenttype',
        '{DAV:}getlastmodified',
        '{DAV:}iscollection',
        '{DAV:}resourcetype',
    ];

    /**
     * @var array
     */
    protected static $resultMap = [
        '{DAV:}getcontentlength' => 'size',
        '{DAV:}getcontenttype' => 'mimetype',
        'content-length' => 'size',
        'content-type' => 'mimetype',
    ];

    /**
     * @var Client
     */
    protected $client;

    /**
     * @var bool
     */
    protected $useStreamedCopy = true;

    /**
     * Constructor.
     *
     * @param Client $client
     * @param string $prefix
     * @param bool $useStreamedCopy
     */
    public function __construct(Client $client, $prefix = null, $useStreamedCopy = true)
    {
        $this->client = $client;
        $this->setPathPrefix($prefix);
        $this->setUseStreamedCopy($useStreamedCopy);
    }

    /**
     * url encode a path
     *
     * @param string $path
     *
     * @return string
     */
    protected function encodePath($path)
	{
		$a = explode('/', $path);
		for ($i=0; $i<count($a); $i++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
			$a[$i] = rawurlencode($a[$i]);
		}
		return implode('/', $a);
	}

    /**
     * {@inheritdoc}
     */
    public function getMetadata($path)
    {
        $location = $this->applyPathPrefix($this->encodePath($path));

        try {
            $result = $this->client->propFind($location, static::$metadataFields);

            if (empty($result)) {
                return false;
            }

            return $this->normalizeObject($result, $path);
        } catch (Exception $e) {
            return false;
        } catch (HttpException $e) {
            return false;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function has($path)
    {
        return $this->getMetadata($path);
    }

    /**
     * {@inheritdoc}
     */
    public function read($path)
    {
        $location = $this->applyPathPrefix($this->encodePath($path));

        try {
            $response = $this->client->request('GET', $location);

            if ($response['statusCode'] !== 200) {
                return false;
            }

            return array_merge([
                'contents' => $response['body'],
                'timestamp' => strtotime(is_array($response['headers']['last-modified'])
                    ? current($response['headers']['last-modified'])
                    : $response['headers']['last-modified']),
                'path' => $path,
            ], Util::map($response['headers'], static::$resultMap));
        } catch (Exception $e) {
            return false;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function write($path, $contents, Config $config)
    {
        if (!$this->createDir(Util::dirname($path), $config)) {
            return false;
        }

        $location = $this->applyPathPrefix($this->encodePath($path));
        $response = $this->client->request('PUT', $location, $contents);

        if ($response['statusCode'] >= 400) {
            return false;
        }

        $result = compact('path', 'contents');

        if ($config->get('visibility')) {
            throw new LogicException(__CLASS__.' does not support visibility settings.');
        }

        return $result;
    }

    /**
     * {@inheritdoc}
     */
    public function writeStream($path, $resource, Config $config)
    {
        return $this->write($path, $resource, $config);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * {@inheritdoc}
     */
    public function update($path, $contents, Config $config)
    {
        return $this->write($path, $contents, $config);
    }

    /**
     * {@inheritdoc}
     */
    public function updateStream($path, $resource, Config $config)
    {
        return $this->update($path, $resource, $config);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * {@inheritdoc}
     */
    public function rename($path, $newpath)
    {
        $location = $this->applyPathPrefix($this->encodePath($path));
        $newLocation = $this->applyPathPrefix($this->encodePath($newpath));

        try {
            $response = $this->client->request('MOVE', '/'.ltrim($location, '/'), null, [
                'Destination' => '/'.ltrim($newLocation, '/'),
            ]);

            if ($response['statusCode'] >= 200 && $response['statusCode'] < 300) {
                return true;
            }
        } catch (NotFound $e) {
            // Would have returned false here, but would be redundant
        }

        return false;
    }

    /**
     * {@inheritdoc}
     */
    public function copy($path, $newpath)
    {
        if ($this->useStreamedCopy === true) {
            return $this->streamedCopy($path, $newpath);
        } else {
            return $this->nativeCopy($path, $newpath);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function delete($path)
    {
        $location = $this->applyPathPrefix($this->encodePath($path));

        try {
            $response =  $this->client->request('DELETE', $location)['statusCode'];


            return $response >= 200 && $response < 300;
        } catch (NotFound $e) {
            return false;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function createDir($path, Config $config)
    {
        $encodedPath = $this->encodePath($path);
        $path = trim($path, '/');

        $result = compact('path') + ['type' => 'dir'];

        if (Util::normalizeDirname($path) === '' || $this->has($path)) {
            return $result;
        }

        $directories = explode('/', $path);
        if (count($directories) > 1) {
            $parentDirectories = array_splice($directories, 0, count($directories) - 1);
            if (!$this->createDir(implode('/', $parentDirectories), $config)) {
                return false;
            }
        }

        $location = $this->applyPathPrefix($encodedPath);
        $response = $this->client->request('MKCOL', $location . $this->pathSeparator);

        if ($response['statusCode'] !== 201) {
            return false;
        }

        return $result;
    }

    /**
     * {@inheritdoc}
     */
    public function deleteDir($dirname)
    {
        return $this->delete($dirname);
    }

    /**
     * {@inheritdoc}
     */
    public function listContents($directory = '', $recursive = false)
    {
        $location = $this->applyPathPrefix($this->encodePath($directory));
        $response = $this->client->propFind($location . '/', static::$metadataFields, 1);

        array_shift($response);
        $result = [];

        foreach ($response as $path => $object) {
            $path = $this->removePathPrefix(rawurldecode($path));
            $object = $this->normalizeObject($object, $path);
            $result[] = $object;

            if ($recursive && $object['type'] === 'dir') {
                $result = array_merge($result, $this->listContents($object['path'], true));
            }
        }

        return $result;
    }

    /**
     * {@inheritdoc}
     */
    public function getSize($path)
    {
        return $this->getMetadata($path);
    }

    /**
     * {@inheritdoc}
     */
    public function getTimestamp($path)
    {
        return $this->getMetadata($path);
    }

    /**
     * {@inheritdoc}
     */
    public function getMimetype($path)
    {
        return $this->getMetadata($path);
    }

    /**
     * @return boolean
     */
    public function getUseStreamedCopy()
    {
        return $this->useStreamedCopy;
    }

    /**
     * @param boolean $useStreamedCopy
     */
    public function setUseStreamedCopy($useStreamedCopy)
    {
        $this->useStreamedCopy = (bool)$useStreamedCopy;
    }

    /**
     * Copy a file through WebDav COPY method.
     *
     * @param string $path
     * @param string $newPath
     *
     * @return bool
     */
    protected function nativeCopy($path, $newPath)
    {
        if (!$this->createDir(Util::dirname($newPath), new Config())) {
            return false;
        }

        $location = $this->applyPathPrefix($this->encodePath($path));
        $newLocation = $this->applyPathPrefix($this->encodePath($newPath));

        try {
            $destination = $this->client->getAbsoluteUrl($newLocation);
            $response = $this->client->request('COPY', '/'.ltrim($location, '/'), null, [
                'Destination' => $destination,
            ]);

            if ($response['statusCode'] >= 200 && $response['statusCode'] < 300) {
                return true;
            }
        } catch (NotFound $e) {
            // Would have returned false here, but would be redundant
        }

        return false;
    }

    /**
     * Normalise a WebDAV repsonse object.
     *
     * @param array  $object
     * @param string $path
     *
     * @return array
     */
    protected function normalizeObject(array $object, $path)
    {
        if ($this->isDirectory($object)) {
            return ['type' => 'dir', 'path' => trim($path, '/')];
        }

        $result = Util::map($object, static::$resultMap);

        if (isset($object['{DAV:}getlastmodified'])) {
            $result['timestamp'] = strtotime($object['{DAV:}getlastmodified']);
        }

        $result['type'] = 'file';
        $result['path'] = trim($path, '/');

        return $result;
    }

    /**
     * @param array $object
     * @return bool
     */
    protected function isDirectory(array $object)
    {
        if (isset($object['{DAV:}resourcetype'])) {
            /** @var ResourceType $resourceType */
            $resourceType = $object['{DAV:}resourcetype'];
            return $resourceType->is('{DAV:}collection');
        }

        return isset($object['{DAV:}iscollection']) && $object['{DAV:}iscollection'] === '1';
    }
}


1			<?php
2
3			namespace League\Flysystem\WebDAV;
4
5			use League\Flysystem\Adapter\AbstractAdapter;
6			use League\Flysystem\Adapter\Polyfill\NotSupportingVisibilityTrait;
7			use League\Flysystem\Adapter\Polyfill\StreamedCopyTrait;
8			use League\Flysystem\Adapter\Polyfill\StreamedReadingTrait;
9			use League\Flysystem\Config;
10			use League\Flysystem\Util;
11			use LogicException;
12			use Sabre\DAV\Client;
13			use Sabre\DAV\Exception;
14			use Sabre\DAV\Exception\NotFound;
15			use Sabre\DAV\Xml\Property\ResourceType;
16			use Sabre\HTTP\HttpException;
17
18			class WebDAVAdapter extends AbstractAdapter
19			{
20			use StreamedReadingTrait;
21			use StreamedCopyTrait {
22			StreamedCopyTrait::copy as streamedCopy;
23			}
24			use NotSupportingVisibilityTrait;
25
26			protected static $metadataFields = [
27			'{DAV:}displayname',
28			'{DAV:}getcontentlength',
29			'{DAV:}getcontenttype',
30			'{DAV:}getlastmodified',
31			'{DAV:}iscollection',
32			'{DAV:}resourcetype',
33			];
34
35			/**
36			* @var array
37			*/
38			protected static $resultMap = [
39			'{DAV:}getcontentlength' => 'size',
40			'{DAV:}getcontenttype' => 'mimetype',
41			'content-length' => 'size',
42			'content-type' => 'mimetype',
43			];
44
45			/**
46			* @var Client
47			*/
48			protected $client;
49
50			/**
51			* @var bool
52			*/
53			protected $useStreamedCopy = true;
54
55			/**
56			* Constructor.
57			*
58			* @param Client $client
59			* @param string $prefix
60			* @param bool $useStreamedCopy
61			*/
62			public function __construct(Client $client, $prefix = null, $useStreamedCopy = true)
63			{
64			$this->client = $client;
65			$this->setPathPrefix($prefix);
66			$this->setUseStreamedCopy($useStreamedCopy);
67			}
68
69			/**
70			* url encode a path
71			*
72			* @param string $path
73			*
74			* @return string
75			*/
76			protected function encodePath($path)
77			{
78			$a = explode('/', $path);
79			for ($i=0; $i<count($a); $i++) {
			0 ignored issues – show Performance Best Practice introduced 2016-05-22 16:06 UTC by Report Bug Copy Issue Report Show Similar Issues like this It seems like you are calling the size function `count()` as part of the test condition. You might want to compute the size beforehand, and not on each iteration. If the size of the collection does not change during the iteration, it is generally a good practice to compute it beforehand, and not on each iteration: for ($i=0; $i<count($array); $i++) { // calls count() on each iteration } // Better for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once } Loading history...
80			$a[$i] = rawurlencode($a[$i]);
81			}
82			return implode('/', $a);
83			}
84
85			/**
86			* {@inheritdoc}
87			*/
88			public function getMetadata($path)
89			{
90			$location = $this->applyPathPrefix($this->encodePath($path));
91
92			try {
93			$result = $this->client->propFind($location, static::$metadataFields);
94
95			if (empty($result)) {
96			return false;
97			}
98
99			return $this->normalizeObject($result, $path);
100			} catch (Exception $e) {
101			return false;
102			} catch (HttpException $e) {
103			return false;
104			}
105			}
106
107			/**
108			* {@inheritdoc}
109			*/
110			public function has($path)
111			{
112			return $this->getMetadata($path);
113			}
114
115			/**
116			* {@inheritdoc}
117			*/
118			public function read($path)
119			{
120			$location = $this->applyPathPrefix($this->encodePath($path));
121
122			try {
123			$response = $this->client->request('GET', $location);
124
125			if ($response['statusCode'] !== 200) {
126			return false;
127			}
128
129			return array_merge([
130			'contents' => $response['body'],
131			'timestamp' => strtotime(is_array($response['headers']['last-modified'])
132			? current($response['headers']['last-modified'])
133			: $response['headers']['last-modified']),
134			'path' => $path,
135			], Util::map($response['headers'], static::$resultMap));
136			} catch (Exception $e) {
137			return false;
138			}
139			}
140
141			/**
142			* {@inheritdoc}
143			*/
144			public function write($path, $contents, Config $config)
145			{
146			if (!$this->createDir(Util::dirname($path), $config)) {
147			return false;
148			}
149
150			$location = $this->applyPathPrefix($this->encodePath($path));
151			$response = $this->client->request('PUT', $location, $contents);
152
153			if ($response['statusCode'] >= 400) {
154			return false;
155			}
156
157			$result = compact('path', 'contents');
158
159			if ($config->get('visibility')) {
160			throw new LogicException(__CLASS__.' does not support visibility settings.');
161			}
162
163			return $result;
164			}
165
166			/**
167			* {@inheritdoc}
168			*/
169			public function writeStream($path, $resource, Config $config)
170			{
171			return $this->write($path, $resource, $config);
			0 ignored issues – show Documentation introduced 2017-11-07 01:09 UTC by Report Bug Copy Issue Report Show Similar Issues like this `$resource` is of type `resource`, but the function expects a `string`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
172			}
173
174			/**
175			* {@inheritdoc}
176			*/
177			public function update($path, $contents, Config $config)
178			{
179			return $this->write($path, $contents, $config);
180			}
181
182			/**
183			* {@inheritdoc}
184			*/
185			public function updateStream($path, $resource, Config $config)
186			{
187			return $this->update($path, $resource, $config);
			0 ignored issues – show Documentation introduced 2017-11-07 01:09 UTC by Report Bug Copy Issue Report Show Similar Issues like this `$resource` is of type `resource`, but the function expects a `string`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
188			}
189
190			/**
191			* {@inheritdoc}
192			*/
193			public function rename($path, $newpath)
194			{
195			$location = $this->applyPathPrefix($this->encodePath($path));
196			$newLocation = $this->applyPathPrefix($this->encodePath($newpath));
197
198			try {
199			$response = $this->client->request('MOVE', '/'.ltrim($location, '/'), null, [
200			'Destination' => '/'.ltrim($newLocation, '/'),
201			]);
202
203			if ($response['statusCode'] >= 200 && $response['statusCode'] < 300) {
204			return true;
205			}
206			} catch (NotFound $e) {
207			// Would have returned false here, but would be redundant
208			}
209
210			return false;
211			}
212
213			/**
214			* {@inheritdoc}
215			*/
216			public function copy($path, $newpath)
217			{
218			if ($this->useStreamedCopy === true) {
219			return $this->streamedCopy($path, $newpath);
220			} else {
221			return $this->nativeCopy($path, $newpath);
222			}
223			}
224
225			/**
226			* {@inheritdoc}
227			*/
228			public function delete($path)
229			{
230			$location = $this->applyPathPrefix($this->encodePath($path));
231
232			try {
233			$response = $this->client->request('DELETE', $location)['statusCode'];
234
235
236			return $response >= 200 && $response < 300;
237			} catch (NotFound $e) {
238			return false;
239			}
240			}
241
242			/**
243			* {@inheritdoc}
244			*/
245			public function createDir($path, Config $config)
246			{
247			$encodedPath = $this->encodePath($path);
248			$path = trim($path, '/');
249
250			$result = compact('path') + ['type' => 'dir'];
251
252			if (Util::normalizeDirname($path) === '' \|\| $this->has($path)) {
253			return $result;
254			}
255
256			$directories = explode('/', $path);
257			if (count($directories) > 1) {
258			$parentDirectories = array_splice($directories, 0, count($directories) - 1);
259			if (!$this->createDir(implode('/', $parentDirectories), $config)) {
260			return false;
261			}
262			}
263
264			$location = $this->applyPathPrefix($encodedPath);
265			$response = $this->client->request('MKCOL', $location . $this->pathSeparator);
266
267			if ($response['statusCode'] !== 201) {
268			return false;
269			}
270
271			return $result;
272			}
273
274			/**
275			* {@inheritdoc}
276			*/
277			public function deleteDir($dirname)
278			{
279			return $this->delete($dirname);
280			}
281
282			/**
283			* {@inheritdoc}
284			*/
285			public function listContents($directory = '', $recursive = false)
286			{
287			$location = $this->applyPathPrefix($this->encodePath($directory));
288			$response = $this->client->propFind($location . '/', static::$metadataFields, 1);
289
290			array_shift($response);
291			$result = [];
292
293			foreach ($response as $path => $object) {
294			$path = $this->removePathPrefix(rawurldecode($path));
295			$object = $this->normalizeObject($object, $path);
296			$result[] = $object;
297
298			if ($recursive && $object['type'] === 'dir') {
299			$result = array_merge($result, $this->listContents($object['path'], true));
300			}
301			}
302
303			return $result;
304			}
305
306			/**
307			* {@inheritdoc}
308			*/
309			public function getSize($path)
310			{
311			return $this->getMetadata($path);
312			}
313
314			/**
315			* {@inheritdoc}
316			*/
317			public function getTimestamp($path)
318			{
319			return $this->getMetadata($path);
320			}
321
322			/**
323			* {@inheritdoc}
324			*/
325			public function getMimetype($path)
326			{
327			return $this->getMetadata($path);
328			}
329
330			/**
331			* @return boolean
332			*/
333			public function getUseStreamedCopy()
334			{
335			return $this->useStreamedCopy;
336			}
337
338			/**
339			* @param boolean $useStreamedCopy
340			*/
341			public function setUseStreamedCopy($useStreamedCopy)
342			{
343			$this->useStreamedCopy = (bool)$useStreamedCopy;
344			}
345
346			/**
347			* Copy a file through WebDav COPY method.
348			*
349			* @param string $path
350			* @param string $newPath
351			*
352			* @return bool
353			*/
354			protected function nativeCopy($path, $newPath)
355			{
356			if (!$this->createDir(Util::dirname($newPath), new Config())) {
357			return false;
358			}
359
360			$location = $this->applyPathPrefix($this->encodePath($path));
361			$newLocation = $this->applyPathPrefix($this->encodePath($newPath));
362
363			try {
364			$destination = $this->client->getAbsoluteUrl($newLocation);
365			$response = $this->client->request('COPY', '/'.ltrim($location, '/'), null, [
366			'Destination' => $destination,
367			]);
368
369			if ($response['statusCode'] >= 200 && $response['statusCode'] < 300) {
370			return true;
371			}
372			} catch (NotFound $e) {
373			// Would have returned false here, but would be redundant
374			}
375
376			return false;
377			}
378
379			/**
380			* Normalise a WebDAV repsonse object.
381			*
382			* @param array $object
383			* @param string $path
384			*
385			* @return array
386			*/
387			protected function normalizeObject(array $object, $path)
388			{
389			if ($this->isDirectory($object)) {
390			return ['type' => 'dir', 'path' => trim($path, '/')];
391			}
392
393			$result = Util::map($object, static::$resultMap);
394
395			if (isset($object['{DAV:}getlastmodified'])) {
396			$result['timestamp'] = strtotime($object['{DAV:}getlastmodified']);
397			}
398
399			$result['type'] = 'file';
400			$result['path'] = trim($path, '/');
401
402			return $result;
403			}
404
405			/**
406			* @param array $object
407			* @return bool
408			*/
409			protected function isDirectory(array $object)
410			{
411			if (isset($object['{DAV:}resourcetype'])) {
412			/** @var ResourceType $resourceType */
413			$resourceType = $object['{DAV:}resourcetype'];
414			return $resourceType->is('{DAV:}collection');
415			}
416
417			return isset($object['{DAV:}iscollection']) && $object['{DAV:}iscollection'] === '1';
418			}
419			}
420

thephpleague / flysystem-webdav

Issues (3)

Security Analysis not enabled

src/WebDAVAdapter.php (3 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like