AbstractScanner::fwrite() - Code Metrics - owncloud/files_antivirus - Measure and Improve Code Quality continuously with Scrutinizer

AbstractScanner::fwrite() B
last analyzed 2018-10-25 00:30 UTC

↳ Parent: AbstractScanner

Complexity

Conditions	7
Paths	11

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	13
CRAP Score	9.71

Importance

Changes

Metric	Value
dl	0
loc	31
ccs	13
cts	21
cp	0.619
rs	8.4906
c	0
b	0
f	0
cc	7
nc	11
nop	1
crap	9.71

<?php
/**
 * ownCloud - Files_antivirus
 *
 * @author Manuel Deglado <[email protected]>
 * @author Viktar Dubiniuk <[email protected]>
 *
 * @copyright 2012 Manuel Deglado [email protected]
 * @copyright 2014-2018 Viktar Dubiniuk
 * @license AGPL-3.0
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU AFFERO GENERAL PUBLIC LICENSE
 * License as published by the Free Software Foundation; either
 * version 3 of the License, or any later version.
 *
 * This library 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 AFFERO GENERAL PUBLIC LICENSE for more details.
 *
 * You should have received a copy of the GNU Affero General Public
 * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

namespace OCA\Files_Antivirus\Scanner;

use OCA\Files_Antivirus\AppConfig;
use OCA\Files_Antivirus\IScannable;
use OCA\Files_Antivirus\Status;
use OCP\ILogger;

abstract class AbstractScanner {
	
	/**
	 * Scan result
	 *
	 * @var Status
	 */
	protected $status;

	/**
	 * If scanning was done part by part
	 * the first detected infected part is stored here
	 *
	 * @var Status
	 */
	protected $infectedStatus;

	/**
	 * @var int
	 */
	protected $byteCount;

	/**
	 * @var resource
	 */
	protected $writeHandle;

	/**
	 * @var AppConfig
	 */
	protected $appConfig;

	/**
	 * @var  ILogger
	 */
	protected $logger;

	/**
	 * @var string
	 */
	protected $lastChunk;

	/**
	 * @var bool
	 */
	protected $isLogUsed = false;

	/**
	 * @var bool
	 */
	protected $isAborted = false;

	/**
	 * Close used resources
	 */
	abstract protected function shutdownScanner();

	/**
	 * AbstractScanner constructor.
	 *
	 * @param AppConfig $config
	 * @param ILogger $logger
	 */
	public function __construct(AppConfig $config, ILogger $logger) {
		$this->appConfig = $config;
		$this->logger = $logger;
	}

	/**
	 * @return Status
	 */
	public function getStatus() {
		if ($this->infectedStatus instanceof Status) {
			return $this->infectedStatus;
		}
		if ($this->status instanceof Status) {
			return $this->status;
		}
		return new Status();
	}

	/**
	 * Synchronous scan
	 *
	 * @param IScannable $item
	 *
	 * @return Status
	 */
	public function scan(IScannable $item) {
		$this->initScanner();

		while (($chunk = $item->fread()) !== false) {
			$this->writeChunk($chunk);
		}
		
		$this->shutdownScanner();
		return $this->getStatus();
	}
	
	/**
	 * Async scan - new portion of data is available
	 *
	 * @param string $data
	 */
	public function onAsyncData($data) {
		$this->writeChunk($data);
	}
	
	/**
	 * Async scan - resource is closed
	 *
	 * @return Status
	 */
	public function completeAsyncScan() {
		$this->shutdownScanner();
		return $this->getStatus();
	}
	
	/**
	 * Get write handle here.
	 * Do NOT open connection in constructor because this method
	 * is used for reconnection
	 */
	public function initScanner() {
		$this->byteCount = 0;
		if ($this->status instanceof Status
			&& $this->status->getNumericStatus() === Status::SCANRESULT_INFECTED
		) {
			$this->infectedStatus = clone $this->status;
		}
		$this->status = new Status();
	}

	/**
	 * @param string $chunk
	 */
	protected function writeChunk($chunk) {
		$this->fwrite(
			$this->prepareChunk($chunk)
		);
	}

	/**
	 * @param string $data
	 */
	final protected function fwrite($data) {
		if ($this->isAborted) {
			return;
		}

		$dataLength = \strlen($data);
		$streamSizeLimit = \intval($this->appConfig->getAvStreamMaxLength());
		if ($this->byteCount + $dataLength > $streamSizeLimit) {
			$this->logger->debug(
				'reinit scanner',
				['app' => 'files_antivirus']
			);
			$this->shutdownScanner();
			$isReopenSuccessful = $this->retry();
		} else {
			$isReopenSuccessful = true;
		}

		if (!$isReopenSuccessful || !$this->writeRaw($data)) {
			if (!$this->isLogUsed) {
				$this->isLogUsed = true;
				$this->logger->warning(
					'Failed to write a chunk. Check if Stream Length matches StreamMaxLength in ClamAV daemon settings',
					['app' => 'files_antivirus']
				);
			}
			// retry on error
			$isRetrySuccessful = $this->retry() && $this->writeRaw($data);
			$this->isAborted = !$isRetrySuccessful;
		}
	}

	/**
	 * @return bool
	 */
	protected function retry() {
		$this->initScanner();
		if ($this->lastChunk !== null) {
			return $this->writeRaw($this->lastChunk);
		}
		return true;
	}

	/**
	 * @param string $data
	 *
	 * @return bool
	 */
	protected function writeRaw($data) {
		$dataLength = \strlen($data);
		$bytesWritten = @\fwrite($this->getWriteHandle(), $data);
		if ($bytesWritten === $dataLength) {
			$this->byteCount += $bytesWritten;
			$this->lastChunk = $data;
			return true;
		}
		return false;
	}

	/**
	 * Get a resource to write data into
	 *
	 * @return resource
	 */
	protected function getWriteHandle() {
		return $this->writeHandle;
	}

	/**
	 * Prepare chunk (if needed)
	 *
	 * @param string $data
	 *
	 * @return string
	 */
	protected function prepareChunk($data) {
		return $data;
	}
}


1		<?php
2		/**
3		* ownCloud - Files_antivirus
4		*
5		* @author Manuel Deglado <[email protected]>
6		* @author Viktar Dubiniuk <[email protected]>
7		*
8		* @copyright 2012 Manuel Deglado [email protected]
9		* @copyright 2014-2018 Viktar Dubiniuk
10		* @license AGPL-3.0
11		*
12		* This library is free software; you can redistribute it and/or
13		* modify it under the terms of the GNU AFFERO GENERAL PUBLIC LICENSE
14		* License as published by the Free Software Foundation; either
15		* version 3 of the License, or any later version.
16		*
17		* This library is distributed in the hope that it will be useful,
18		* but WITHOUT ANY WARRANTY; without even the implied warranty of
19		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20		* GNU AFFERO GENERAL PUBLIC LICENSE for more details.
21		*
22		* You should have received a copy of the GNU Affero General Public
23		* License along with this library. If not, see <http://www.gnu.org/licenses/>.
24		*
25		*/
26
27		namespace OCA\Files_Antivirus\Scanner;
28
29		use OCA\Files_Antivirus\AppConfig;
30		use OCA\Files_Antivirus\IScannable;
31		use OCA\Files_Antivirus\Status;
32		use OCP\ILogger;
33
34		abstract class AbstractScanner {
35
36		/**
37		* Scan result
38		*
39		* @var Status
40		*/
41		protected $status;
42
43		/**
44		* If scanning was done part by part
45		* the first detected infected part is stored here
46		*
47		* @var Status
48		*/
49		protected $infectedStatus;
50
51		/**
52		* @var int
53		*/
54		protected $byteCount;
55
56		/**
57		* @var resource
58		*/
59		protected $writeHandle;
60
61		/**
62		* @var AppConfig
63		*/
64		protected $appConfig;
65
66		/**
67		* @var ILogger
68		*/
69		protected $logger;
70
71		/**
72		* @var string
73		*/
74		protected $lastChunk;
75
76		/**
77		* @var bool
78		*/
79		protected $isLogUsed = false;
80
81		/**
82		* @var bool
83		*/
84		protected $isAborted = false;
85
86		/**
87		* Close used resources
88		*/
89		abstract protected function shutdownScanner();
90
91		/**
92		* AbstractScanner constructor.
93		*
94		* @param AppConfig $config
95		* @param ILogger $logger
96		*/
97	12	public function __construct(AppConfig $config, ILogger $logger) {
98	12	$this->appConfig = $config;
99	12	$this->logger = $logger;
100	12	}
101
102		/**
103		* @return Status
104		*/
105	7	public function getStatus() {
106	7	if ($this->infectedStatus instanceof Status) {
107		return $this->infectedStatus;
108		}
109	7	if ($this->status instanceof Status) {
110	7	return $this->status;
111		}
112		return new Status();
113		}
114
115		/**
116		* Synchronous scan
117		*
118		* @param IScannable $item
119		*
120		* @return Status
121		*/
122	2	public function scan(IScannable $item) {
123	2	$this->initScanner();
124
125	2	while (($chunk = $item->fread()) !== false) {
126	2	$this->writeChunk($chunk);
127		}
128
129	2	$this->shutdownScanner();
130	2	return $this->getStatus();
131		}
132
133		/**
134		* Async scan - new portion of data is available
135		*
136		* @param string $data
137		*/
138	5	public function onAsyncData($data) {
139	5	$this->writeChunk($data);
140	5	}
141
142		/**
143		* Async scan - resource is closed
144		*
145		* @return Status
146		*/
147	5	public function completeAsyncScan() {
148	5	$this->shutdownScanner();
149	5	return $this->getStatus();
150		}
151
152		/**
153		* Get write handle here.
154		* Do NOT open connection in constructor because this method
155		* is used for reconnection
156		*/
157	9	public function initScanner() {
158	9	$this->byteCount = 0;
159	9	if ($this->status instanceof Status
160	9	&& $this->status->getNumericStatus() === Status::SCANRESULT_INFECTED
161		) {
162		$this->infectedStatus = clone $this->status;
163		}
164	9	$this->status = new Status();
165	9	}
166
167		/**
168		* @param string $chunk
169		*/
170	7	protected function writeChunk($chunk) {
171	7	$this->fwrite(
172	7	$this->prepareChunk($chunk)
173		);
174	7	}
175
176		/**
177		* @param string $data
178		*/
179	7	final protected function fwrite($data) {
180	7	if ($this->isAborted) {
181		return;
182		}
183
184	7	$dataLength = \strlen($data);
185	7	$streamSizeLimit = \intval($this->appConfig->getAvStreamMaxLength());
186	7	if ($this->byteCount + $dataLength > $streamSizeLimit) {
187	3	$this->logger->debug(
188	3	'reinit scanner',
189	3	['app' => 'files_antivirus']
190		);
191	3	$this->shutdownScanner();
192	3	$isReopenSuccessful = $this->retry();
193		} else {
194	5	$isReopenSuccessful = true;
195		}
196
197	7	if (!$isReopenSuccessful \|\| !$this->writeRaw($data)) {
198		if (!$this->isLogUsed) {
199		$this->isLogUsed = true;
200		$this->logger->warning(
201		'Failed to write a chunk. Check if Stream Length matches StreamMaxLength in ClamAV daemon settings',
202		['app' => 'files_antivirus']
203		);
204		}
205		// retry on error
206		$isRetrySuccessful = $this->retry() && $this->writeRaw($data);
207		$this->isAborted = !$isRetrySuccessful;
208		}
209	7	}
210
211		/**
212		* @return bool
213		*/
214	3	protected function retry() {
215	3	$this->initScanner();
216	3	if ($this->lastChunk !== null) {
217	1	return $this->writeRaw($this->lastChunk);
218		}
219	2	return true;
220		}
221
222		/**
223		* @param string $data
224		*
225		* @return bool
226		*/
227	7	protected function writeRaw($data) {
228	7	$dataLength = \strlen($data);
229	7	$bytesWritten = @\fwrite($this->getWriteHandle(), $data);
230	7	if ($bytesWritten === $dataLength) {
231	7	$this->byteCount += $bytesWritten;
232	7	$this->lastChunk = $data;
233	7	return true;
234		}
235		return false;
236		}
237
238		/**
239		* Get a resource to write data into
240		*
241		* @return resource
242		*/
243	9	protected function getWriteHandle() {
244	9	return $this->writeHandle;
245		}
246
247		/**
248		* Prepare chunk (if needed)
249		*
250		* @param string $data
251		*
252		* @return string
253		*/
254	3	protected function prepareChunk($data) {
255	3	return $data;
256		}
257		}
258

owncloud / files_antivirus

AbstractScanner::fwrite() B last analyzed 2018-10-25 00:30 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

AbstractScanner::fwrite() B
last analyzed 2018-10-25 00:30 UTC