Path::get_home_path() - Code Metrics - Inspection of "Ensure our subdirectory check doesn't also match w..." - humanmade/backupwordpress - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#983)

by Tom

created 2016-02-04 11:22 UTC

Path::get_home_path() C

↳ Parent: Path

Complexity

Conditions	8
Paths	4

Size

Total Lines	24
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes	6
Bugs	0	Features	0

Metric	Value
c	6
b	0
f	0
dl	0
loc	24
rs	5.7377
cc	8
eloc	8
nc	4
nop	1

<?php

namespace HM\BackUpWordPress;

/**
 * Manages both the backup path and site root
 *
 * Handles calculating & protecting the directory that backups will be stored in
 * as well as the directory that is being backed up
 */
class Path {

	/**
	 * The path to the directory that backup files are stored in
	 *
	 * @var string $this->path
	 */
	private $path;

	/**
	 * The path to the directory that will be backed up
	 *
	 * @var string $this->root
	 */
	private $root;

	/**
	 * The path to the directory that backup files are stored in
	 *
	 * @var string $this->path
	 */
	private $custom_path;

	/**
	 * Contains the instantiated Path instance
	 *
	 * @var Path $this->instance
	 */
	private static $instance;

	/**
	 * Protected constructor to prevent creating a new instance of the
	 * *Singleton* via the `new` operator from outside of this class.
	 */
	protected function __construct() {}

	/**
	 * Private clone method to prevent cloning of the instance of the
	 * *Singleton* instance.
	 */
	private function __clone() {}

	/**
	 * Private unserialize method to prevent unserializing of the *Singleton*
	 * instance.
	 */
	private function __wakeup() {}

	/**
	 * Returns the *Singleton* instance of this class.
	 *
	 * @staticvar Path $instance The *Singleton* instances of this class.
	 *
	 * @return Path The *Singleton* instance.
	 */
	public static function get_instance() {

		if ( ! ( self::$instance instanceof Path ) ) {
			self::$instance = new Path();
		}

		return self::$instance;
	}

	/**
	 * Convenience method for quickly grabbing the path
	 */
	public static function get_path() {

		return self::get_instance()->get_calculated_path();
	}

	/**
	 * Convenience method for quickly grabbing the root
	 */
	public static function get_root() {

		return self::get_instance()->get_calculated_root();
	}

	/**
	 * Calculate the path to the site "home" directory.
	 *
	 * The home directory is the path equivalent to the home_url. That is,
	 * the path to the true root of the website. In situations where WordPress is
	 * installed in a subdirectory the home path is different to ABSPATH
	 *
	 * @param string $site_path The site_path to use when calculating the home path, defaults to ABSPATH
	 */
	public static function get_home_path( $site_path = ABSPATH ) {


		if ( defined( 'HMBKP_ROOT' ) && HMBKP_ROOT ) {
			return wp_normalize_path( HMBKP_ROOT );
		}

		$home_path = $site_path;

		if ( path_in_php_open_basedir( dirname( $site_path ) ) ) {

			/**
			 * Standard subdirectory install
			 *
			 * index.php in parent directory and not in root
			 * wp-config either in root or parent
			 */
			if ( file_exists( dirname( $site_path ) . '/index.php' ) && ! file_exists( $site_path . '/index.php' ) && ( file_exists( dirname( $site_path ) . '/wp-config.php' ) || file_exists( $site_path . '/wp-config.php' ) ) ) {
				$home_path = dirname( $site_path );
			}
		}

		return wp_normalize_path( untrailingslashit( $home_path ) );

	}

	/**
	 * get the calculated path to the directory where backups will be stored
	 */
	private function get_calculated_path() {


		// Calculate the path if needed
		if ( empty( $this->path ) || ! wp_is_writable( $this->path ) ) {
			$this->calculate_path();
		}

		// Ensure the backup directory is protected
		$this->protect_path();

		return wp_normalize_path( $this->path );

	}

	/**
	 * Set the path directly, overriding the default
	 *
	 * @param $path
	 */
	public function set_path( $path ) {

		$this->custom_path = $path;

		// Re-calculate the backup path
		$this->calculate_path();

	}

	/**
	 * get the calculated path to the directory that will be backed up
	 */
	private function get_calculated_root() {


		$root = self::get_home_path();

		if ( defined( 'HMBKP_ROOT' ) && HMBKP_ROOT ) {
			$root = HMBKP_ROOT;
		}

		if ( $this->root ) {
			$root = $this->root;
		}

		return wp_normalize_path( $root );

	}

	/**
	 * Set the root path directly, overriding the default
	 *
	 * @param $root
	 */
	public function set_root( $root ) {
		$this->root = $root;
	}

	public function reset_path() {
		$this->set_path( false );
	}

	/**
	 * Get the path to the default backup location in wp-content
	 */
	public function get_default_path() {
		return trailingslashit( wp_normalize_path( WP_CONTENT_DIR ) ) . 'backupwordpress-' . substr( HMBKP_SECURE_KEY, 0, 10 ) . '-backups';
	}

	/**
	 * Get the path to the fallback backup location in uploads
	 */
	public function get_fallback_path() {

		$upload_dir = wp_upload_dir();

		return trailingslashit( wp_normalize_path( $upload_dir['basedir'] ) ) . 'backupwordpress-' . substr( HMBKP_SECURE_KEY, 0, 10 ) . '-backups';

	}

	/**
	 * Get the path to the custom backup location if it's been set
	 */
	public function get_custom_path() {


		if ( $this->custom_path ) {
			return $this->custom_path;
		}

		if ( defined( 'HMBKP_PATH' ) && wp_is_writable( HMBKP_PATH ) ) {
			return HMBKP_PATH;
		}

		return '';

	}

	/**
	 * Builds an array containing existing backups folders.
	 *
	 * @return array
	 */
	public function get_existing_paths() {

		if ( false === $default = glob( WP_CONTENT_DIR . '/backupwordpress-*-backups', GLOB_ONLYDIR ) ) {
			$default = array();
		}

		$upload_dir = wp_upload_dir();

		if ( false === $fallback = glob( $upload_dir['basedir'] . '/backupwordpress-*-backups', GLOB_ONLYDIR ) ) {
			$fallback = array();
		}

		$paths = array_merge( $default, $fallback );

        $paths = array_map( 'wp_normalize_path', $paths );

		return $paths;

	}

	/**
	 * Returns the first existing path if there is one
	 *
	 * @return string Backup path if found empty string if not
	 */
	public function get_existing_path() {

		$paths = $this->get_existing_paths();

		if ( ! empty( $paths[0] ) ) {
			return $paths[0];
		}

		return '';

	}

	/**
	 * Calculate the backup path and create the directory if it doesn't exist.
	 *
	 * Tries all possible locations and uses the first one possible
	 *
	 * @return
	 */
	public function calculate_path() {

		$paths = array();

		// If we have a custom path then try to use it
		if ( $this->get_custom_path() ) {
			$paths[] = $this->get_custom_path();
		}

		// If there is already a backups directory then try to use that
		if ( $this->get_existing_path() ) {
			$paths[] = $this->get_existing_path();
		}

		// If not then default to a new directory in wp-content
		$paths[] = $this->get_default_path();

		// If that didn't work then fallback to a new directory in uploads
		$paths[] = $this->get_fallback_path();

		// Loop through possible paths, use the first one that exists/can be created and is writable
		foreach ( $paths as $path ) {
			if ( wp_mkdir_p( $path ) && wp_is_writable( $path ) ) { // Also handles fixing perms / directory already exists
				break;
			}
		}

		if ( file_exists( $path ) && wp_is_writable( $path ) ) {
			$this->path = $path;
foreach ($a as $b) {
}

// $b is defined here only if $a has elements, for example if $a is array()
// then $b would not be defined here. To avoid that, we recommend to set a
// default value for $b.


// Better
$b = 0; // or whatever default makes sense in your context
foreach ($a as $b) {
}

// $b is now guaranteed to be defined here.
		}

	}

	/**
	 * Protect the directory that backups are stored in
	 *
	 * - Adds an index.html file in an attempt to disable directory browsing
	 * - Adds a .httaccess file to deny direct access if on Apache
	 *
	 * @param string $reset
	 */
	public function protect_path( $reset = 'no' ) {

		global $is_apache;
function myFunction($a, $b) {
    // Do something
}

		// Protect against directory browsing by including an index.html file
		$index = $this->path . '/index.html';

		if ( 'reset' === $reset && file_exists( $index ) ) {
			@unlink( $index );
// For example instead of
@mkdir($dir);

// Better use
if (@mkdir($dir) === false) {
    throw new \RuntimeException('The directory '.$dir.' could not be created.');
}
		}

		if ( ! file_exists( $index ) && wp_is_writable( $this->path ) ) {
			file_put_contents( $index, '' );
		}

		$htaccess = $this->path . '/.htaccess';

		if ( ( 'reset' === $reset ) && file_exists( $htaccess ) ) {
			@unlink( $htaccess );
// For example instead of
@mkdir($dir);

// Better use
if (@mkdir($dir) === false) {
    throw new \RuntimeException('The directory '.$dir.' could not be created.');
}
		}

		// Protect the directory with a .htaccess file on Apache servers
		if ( $is_apache && function_exists( 'insert_with_markers' ) && ! file_exists( $htaccess ) && wp_is_writable( $this->path ) ) {

			$contents[] = '# ' . sprintf( __( 'This %s file ensures that other people cannot download your backup files.', 'backupwordpress' ), '.htaccess' );
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}
			$contents[] = '';
			$contents[] = '<IfModule mod_rewrite.c>';
			$contents[] = 'RewriteEngine On';
			$contents[] = 'RewriteCond %{QUERY_STRING} !key=' . HMBKP_SECURE_KEY;
			$contents[] = 'RewriteRule (.*) - [F]';
			$contents[] = '</IfModule>';
			$contents[] = '';

			file_put_contents( $htaccess, '' );

			insert_with_markers( $htaccess, 'BackUpWordPress', $contents );

		}

	}

	/**
	 * If we have more than one path then move any existing backups to the current path and remove them
	 */
	public function merge_existing_paths() {

		$paths = $this->get_existing_paths();

		if ( ( $paths && $this->get_custom_path() ) || count( $paths ) > 1 ) {

			foreach ( $paths as $old_path ) {
				$this->move_old_backups( $old_path );
			}
		}

	}

	/**
	 * Move backup files from an existing directory and the new
	 * location
	 *
	 * @param string $path 	The path to move the backups from
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
	 */
	public function move_old_backups( $from ) {

		if ( ! is_readable( $from ) ) {
			return;
		}

		if ( ! wp_is_writable( Path::get_path() ) ) {
			return;
		}

		// Move any existing backups
		if ( $handle = opendir( $from ) ) {

			// Loop through the backup directory
			while ( false !== ( $file = readdir( $handle ) ) ) {

				// Find all zips
				if ( 'zip' === pathinfo( $file, PATHINFO_EXTENSION ) ) {

					// Try to move them
					if ( ! @rename( trailingslashit( $from ) . $file, trailingslashit( Path::get_path() ) . $file ) ) {


						// If we can't move them then try to copy them
						copy( trailingslashit( $from ) . $file, trailingslashit( Path::get_path() ) . $file );

					}

				}
			}

			closedir( $handle );

		}

		// Delete the old directory if it's inside WP_CONTENT_DIR
		if ( false !== strpos( $from, WP_CONTENT_DIR ) && $from !== Path::get_path() ) {
			rmdirtree( $from );
		}

	}

	/**
	 * Clean any temporary / incomplete backups from the backups directory
	 */
	public function cleanup() {

		// Don't cleanup a custom path, who knows what other stuff is there
		if ( Path::get_path() === $this->get_custom_path() ) {
			return;
		}

		foreach ( new CleanUpIterator( new \DirectoryIterator( $this->path ) ) as $file ) {

			if ( $file->isDot() || ! $file->isReadable() || ! $file->isFile() ) {
				continue;
			}

			@unlink( $file->getPathname() );
// For example instead of
@mkdir($dir);

// Better use
if (@mkdir($dir) === false) {
    throw new \RuntimeException('The directory '.$dir.' could not be created.');
}

		}

	}

}

class CleanUpIterator extends \FilterIterator {


	// Don't match index.html,files with zip extension or status logfiles.
	public function accept() {
		return ! preg_match( '/(index\.html|.*\.zip|.*-running)/', $this->current() );
	}
}


GitHub Access Token became invalid

Pull Request — master (#983)

Path::get_home_path() C

Complexity

Size

Duplication

Importance

1. Pass all data via parameters

2. Create a class that maintains your state

1			<?php
2
3			namespace HM\BackUpWordPress;
4
5			/**
6			* Manages both the backup path and site root
7			*
8			* Handles calculating & protecting the directory that backups will be stored in
9			* as well as the directory that is being backed up
10			*/
11			class Path {
12
13			/**
14			* The path to the directory that backup files are stored in
15			*
16			* @var string $this->path
17			*/
18			private $path;
19
20			/**
21			* The path to the directory that will be backed up
22			*
23			* @var string $this->root
24			*/
25			private $root;
26
27			/**
28			* The path to the directory that backup files are stored in
29			*
30			* @var string $this->path
31			*/
32			private $custom_path;
33
34			/**
35			* Contains the instantiated Path instance
36			*
37			* @var Path $this->instance
38			*/
39			private static $instance;
40
41			/**
42			* Protected constructor to prevent creating a new instance of the
43			* Singleton via the `new` operator from outside of this class.
44			*/
45			protected function __construct() {}
46
47			/**
48			* Private clone method to prevent cloning of the instance of the
49			* Singleton instance.
50			*/
51			private function __clone() {}
52
53			/**
54			* Private unserialize method to prevent unserializing of the Singleton
55			* instance.
56			*/
57			private function __wakeup() {}
58
59			/**
60			* Returns the Singleton instance of this class.
61			*
62			* @staticvar Path $instance The Singleton instances of this class.
63			*
64			* @return Path The Singleton instance.
65			*/
66			public static function get_instance() {
67
68			if ( ! ( self::$instance instanceof Path ) ) {
69			self::$instance = new Path();
70			}
71
72			return self::$instance;
73			}
74
75			/**
76			* Convenience method for quickly grabbing the path
77			*/
78			public static function get_path() {
			0 ignored issues – show Documentation introduced 2015-11-21 01:52 UTC by Report Bug Copy Issue Report The return type could not be reliably inferred; please add a `@return` annotation. Our type inference engine in quite powerful, but sometimes the code does not provide enough clues to go by. In these cases we request you to add a `@return` annotation as described here. Loading history...
79			return self::get_instance()->get_calculated_path();
80			}
81
82			/**
83			* Convenience method for quickly grabbing the root
84			*/
85			public static function get_root() {
			0 ignored issues – show Documentation introduced 2015-11-21 01:52 UTC by Report Bug Copy Issue Report The return type could not be reliably inferred; please add a `@return` annotation. Our type inference engine in quite powerful, but sometimes the code does not provide enough clues to go by. In these cases we request you to add a `@return` annotation as described here. Loading history...
86			return self::get_instance()->get_calculated_root();
87			}
88
89			/**
90			* Calculate the path to the site "home" directory.
91			*
92			* The home directory is the path equivalent to the home_url. That is,
93			* the path to the true root of the website. In situations where WordPress is
94			* installed in a subdirectory the home path is different to ABSPATH
95			*
96			* @param string $site_path The site_path to use when calculating the home path, defaults to ABSPATH
97			*/
98			public static function get_home_path( $site_path = ABSPATH ) {
			0 ignored issues – show Documentation introduced 2015-11-21 01:52 UTC by Report Bug Copy Issue Report The return type could not be reliably inferred; please add a `@return` annotation. Our type inference engine in quite powerful, but sometimes the code does not provide enough clues to go by. In these cases we request you to add a `@return` annotation as described here. Loading history...
99
100			if ( defined( 'HMBKP_ROOT' ) && HMBKP_ROOT ) {
101			return wp_normalize_path( HMBKP_ROOT );
102			}
103
104			$home_path = $site_path;
105
106			if ( path_in_php_open_basedir( dirname( $site_path ) ) ) {
107
108			/**
109			* Standard subdirectory install
110			*
111			* index.php in parent directory and not in root
112			* wp-config either in root or parent
113			*/
114			if ( file_exists( dirname( $site_path ) . '/index.php' ) && ! file_exists( $site_path . '/index.php' ) && ( file_exists( dirname( $site_path ) . '/wp-config.php' ) \|\| file_exists( $site_path . '/wp-config.php' ) ) ) {
115			$home_path = dirname( $site_path );
116			}
117			}
118
119			return wp_normalize_path( untrailingslashit( $home_path ) );
120
121			}
122
123			/**
124			* get the calculated path to the directory where backups will be stored
125			*/
126			private function get_calculated_path() {
			0 ignored issues – show Documentation introduced 2015-11-21 01:52 UTC by Report Bug Copy Issue Report The return type could not be reliably inferred; please add a `@return` annotation. Our type inference engine in quite powerful, but sometimes the code does not provide enough clues to go by. In these cases we request you to add a `@return` annotation as described here. Loading history...
127
128			// Calculate the path if needed
129			if ( empty( $this->path ) \|\| ! wp_is_writable( $this->path ) ) {
130			$this->calculate_path();
131			}
132
133			// Ensure the backup directory is protected
134			$this->protect_path();
135
136			return wp_normalize_path( $this->path );
137
138			}
139
140			/**
141			* Set the path directly, overriding the default
142			*
143			* @param $path
144			*/
145			public function set_path( $path ) {
146
147			$this->custom_path = $path;
148
149			// Re-calculate the backup path
150			$this->calculate_path();
151
152			}
153
154			/**
155			* get the calculated path to the directory that will be backed up
156			*/
157			private function get_calculated_root() {
			0 ignored issues – show Documentation introduced 2015-11-21 01:52 UTC by Report Bug Copy Issue Report The return type could not be reliably inferred; please add a `@return` annotation. Our type inference engine in quite powerful, but sometimes the code does not provide enough clues to go by. In these cases we request you to add a `@return` annotation as described here. Loading history...
158
159			$root = self::get_home_path();
160
161			if ( defined( 'HMBKP_ROOT' ) && HMBKP_ROOT ) {
162			$root = HMBKP_ROOT;
163			}
164
165			if ( $this->root ) {
166			$root = $this->root;
167			}
168
169			return wp_normalize_path( $root );
170
171			}
172
173			/**
174			* Set the root path directly, overriding the default
175			*
176			* @param $root
177			*/
178			public function set_root( $root ) {
179			$this->root = $root;
180			}
181
182			public function reset_path() {
183			$this->set_path( false );
184			}
185
186			/**
187			* Get the path to the default backup location in wp-content
188			*/
189			public function get_default_path() {
190			return trailingslashit( wp_normalize_path( WP_CONTENT_DIR ) ) . 'backupwordpress-' . substr( HMBKP_SECURE_KEY, 0, 10 ) . '-backups';
191			}
192
193			/**
194			* Get the path to the fallback backup location in uploads
195			*/
196			public function get_fallback_path() {
197
198			$upload_dir = wp_upload_dir();
199
200			return trailingslashit( wp_normalize_path( $upload_dir['basedir'] ) ) . 'backupwordpress-' . substr( HMBKP_SECURE_KEY, 0, 10 ) . '-backups';
201
202			}
203
204			/**
205			* Get the path to the custom backup location if it's been set
206			*/
207			public function get_custom_path() {
			0 ignored issues – show Documentation introduced 2015-11-21 01:52 UTC by Report Bug Copy Issue Report The return type could not be reliably inferred; please add a `@return` annotation. Our type inference engine in quite powerful, but sometimes the code does not provide enough clues to go by. In these cases we request you to add a `@return` annotation as described here. Loading history...
208
209			if ( $this->custom_path ) {
210			return $this->custom_path;
211			}
212
213			if ( defined( 'HMBKP_PATH' ) && wp_is_writable( HMBKP_PATH ) ) {
214			return HMBKP_PATH;
215			}
216
217			return '';
218
219			}
220
221			/**
222			* Builds an array containing existing backups folders.
223			*
224			* @return array
225			*/
226			public function get_existing_paths() {
227
228			if ( false === $default = glob( WP_CONTENT_DIR . '/backupwordpress-*-backups', GLOB_ONLYDIR ) ) {
229			$default = array();
230			}
231
232			$upload_dir = wp_upload_dir();
233
234			if ( false === $fallback = glob( $upload_dir['basedir'] . '/backupwordpress-*-backups', GLOB_ONLYDIR ) ) {
235			$fallback = array();
236			}
237
238			$paths = array_merge( $default, $fallback );
239
240			$paths = array_map( 'wp_normalize_path', $paths );
241
242			return $paths;
243
244			}
245
246			/**
247			* Returns the first existing path if there is one
248			*
249			* @return string Backup path if found empty string if not
250			*/
251			public function get_existing_path() {
252
253			$paths = $this->get_existing_paths();
254
255			if ( ! empty( $paths[0] ) ) {
256			return $paths[0];
257			}
258
259			return '';
260
261			}
262
263			/**
264			* Calculate the backup path and create the directory if it doesn't exist.
265			*
266			* Tries all possible locations and uses the first one possible
267			*
268			* @return
269			*/
270			public function calculate_path() {
271
272			$paths = array();
273
274			// If we have a custom path then try to use it
275			if ( $this->get_custom_path() ) {
276			$paths[] = $this->get_custom_path();
277			}
278
279			// If there is already a backups directory then try to use that
280			if ( $this->get_existing_path() ) {
281			$paths[] = $this->get_existing_path();
282			}
283
284			// If not then default to a new directory in wp-content
285			$paths[] = $this->get_default_path();
286
287			// If that didn't work then fallback to a new directory in uploads
288			$paths[] = $this->get_fallback_path();
289
290			// Loop through possible paths, use the first one that exists/can be created and is writable
291			foreach ( $paths as $path ) {
292			if ( wp_mkdir_p( $path ) && wp_is_writable( $path ) ) { // Also handles fixing perms / directory already exists
293			break;
294			}
295			}
296
297			if ( file_exists( $path ) && wp_is_writable( $path ) ) {
298			$this->path = $path;
			0 ignored issues – show Bug introduced 2016-02-04 11:26 UTC by Report Bug Copy Issue Report The variable `$path` seems to be defined by a `foreach` iteration on line `291`. Are you sure the iterator is never empty, otherwise this variable is not defined? It seems like you are relying on a variable being defined by an iteration: foreach ($a as $b) { } // $b is defined here only if $a has elements, for example if $a is array() // then $b would not be defined here. To avoid that, we recommend to set a // default value for $b. // Better $b = 0; // or whatever default makes sense in your context foreach ($a as $b) { } // $b is now guaranteed to be defined here. Loading history...
299			}
300
301			}
302
303			/**
304			* Protect the directory that backups are stored in
305			*
306			* - Adds an index.html file in an attempt to disable directory browsing
307			* - Adds a .httaccess file to deny direct access if on Apache
308			*
309			* @param string $reset
310			*/
311			public function protect_path( $reset = 'no' ) {
312
313			global $is_apache;
			1 ignored issue – show Compatibility Best Practice introduced 2015-11-21 01:52 UTC by Report Bug Copy Issue Report Use of `global` functionality is not recommended; it makes your code harder to test, and less reusable. Instead of relying on `global` state, we recommend one of these alternatives: 1. Pass all data via parameters function myFunction($a, $b) { // Do something } 2. Create a class that maintains your state class MyClass { private $a; private $b; public function __construct($a, $b) { $this->a = $a; $this->b = $b; } public function myFunction() { // Do something } } Loading history...
314
315			// Protect against directory browsing by including an index.html file
316			$index = $this->path . '/index.html';
317
318			if ( 'reset' === $reset && file_exists( $index ) ) {
319			@unlink( $index );
			0 ignored issues – show Security Best Practice introduced 2015-11-21 01:52 UTC by Report Bug Copy Issue Report It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended. If you suppress an error, we recommend checking for the error condition explicitly: // For example instead of @mkdir($dir); // Better use if (@mkdir($dir) === false) { throw new \RuntimeException('The directory '.$dir.' could not be created.'); } Loading history...
320			}
321
322			if ( ! file_exists( $index ) && wp_is_writable( $this->path ) ) {
323			file_put_contents( $index, '' );
324			}
325
326			$htaccess = $this->path . '/.htaccess';
327
328			if ( ( 'reset' === $reset ) && file_exists( $htaccess ) ) {
329			@unlink( $htaccess );
			0 ignored issues – show Security Best Practice introduced 2015-11-21 01:52 UTC by Report Bug Copy Issue Report It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended. If you suppress an error, we recommend checking for the error condition explicitly: // For example instead of @mkdir($dir); // Better use if (@mkdir($dir) === false) { throw new \RuntimeException('The directory '.$dir.' could not be created.'); } Loading history...
330			}
331
332			// Protect the directory with a .htaccess file on Apache servers
333			if ( $is_apache && function_exists( 'insert_with_markers' ) && ! file_exists( $htaccess ) && wp_is_writable( $this->path ) ) {
334
335			$contents[] = '# ' . sprintf( __( 'This %s file ensures that other people cannot download your backup files.', 'backupwordpress' ), '.htaccess' );
			0 ignored issues – show Coding Style Comprehensibility introduced 2015-11-21 01:52 UTC by Report Bug Copy Issue Report `$contents` was never initialized. Although not strictly required by PHP, it is generally a good practice to add `$contents = array();` before regardless. Adding an explicit array definition is generally preferable to implicit array definition as it guarantees a stable state of the code. Let’s take a look at an example: foreach ($collection as $item) { $myArray['foo'] = $item->getFoo(); if ($item->hasBar()) { $myArray['bar'] = $item->getBar(); } // do something with $myArray } As you can see in this example, the array `$myArray` is initialized the first time when the foreach loop is entered. You can also see that the value of the `bar` key is only written conditionally; thus, its value might result from a previous iteration. This might or might not be intended. To make your intention clear, your code more readible and to avoid accidental bugs, we recommend to add an explicit initialization `$myArray = array()` either outside or inside the foreach loop. Loading history...
336			$contents[] = '';
337			$contents[] = '<IfModule mod_rewrite.c>';
338			$contents[] = 'RewriteEngine On';
339			$contents[] = 'RewriteCond %{QUERY_STRING} !key=' . HMBKP_SECURE_KEY;
340			$contents[] = 'RewriteRule (.*) - [F]';
341			$contents[] = '</IfModule>';
342			$contents[] = '';
343
344			file_put_contents( $htaccess, '' );
345
346			insert_with_markers( $htaccess, 'BackUpWordPress', $contents );
347
348			}
349
350			}
351
352			/**
353			* If we have more than one path then move any existing backups to the current path and remove them
354			*/
355			public function merge_existing_paths() {
356
357			$paths = $this->get_existing_paths();
358
359			if ( ( $paths && $this->get_custom_path() ) \|\| count( $paths ) > 1 ) {
			0 ignored issues – show Bug Best Practice introduced 2015-11-21 01:52 UTC by Report Bug Copy Issue Report The expression `$paths` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
360			foreach ( $paths as $old_path ) {
361			$this->move_old_backups( $old_path );
362			}
363			}
364
365			}
366
367			/**
368			* Move backup files from an existing directory and the new
369			* location
370			*
371			* @param string $path The path to move the backups from
			0 ignored issues – show Bug introduced 2015-11-21 01:52 UTC by Report Bug Copy Issue Report There is no parameter named `$path`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
372			*/
373			public function move_old_backups( $from ) {
374
375			if ( ! is_readable( $from ) ) {
376			return;
377			}
378
379			if ( ! wp_is_writable( Path::get_path() ) ) {
380			return;
381			}
382
383			// Move any existing backups
384			if ( $handle = opendir( $from ) ) {
385
386			// Loop through the backup directory
387			while ( false !== ( $file = readdir( $handle ) ) ) {
388
389			// Find all zips
390			if ( 'zip' === pathinfo( $file, PATHINFO_EXTENSION ) ) {
391
392			// Try to move them
393			if ( ! @rename( trailingslashit( $from ) . $file, trailingslashit( Path::get_path() ) . $file ) ) {
394
395
396			// If we can't move them then try to copy them
397			copy( trailingslashit( $from ) . $file, trailingslashit( Path::get_path() ) . $file );
398
399			}
400
401			}
402			}
403
404			closedir( $handle );
405
406			}
407
408			// Delete the old directory if it's inside WP_CONTENT_DIR
409			if ( false !== strpos( $from, WP_CONTENT_DIR ) && $from !== Path::get_path() ) {
410			rmdirtree( $from );
411			}
412
413			}
414
415			/**
416			* Clean any temporary / incomplete backups from the backups directory
417			*/
418			public function cleanup() {
419
420			// Don't cleanup a custom path, who knows what other stuff is there
421			if ( Path::get_path() === $this->get_custom_path() ) {
422			return;
423			}
424
425			foreach ( new CleanUpIterator( new \DirectoryIterator( $this->path ) ) as $file ) {
426
427			if ( $file->isDot() \|\| ! $file->isReadable() \|\| ! $file->isFile() ) {
428			continue;
429			}
430
431			@unlink( $file->getPathname() );
			0 ignored issues – show Security Best Practice introduced 2015-11-21 01:52 UTC by Report Bug Copy Issue Report It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended. If you suppress an error, we recommend checking for the error condition explicitly: // For example instead of @mkdir($dir); // Better use if (@mkdir($dir) === false) { throw new \RuntimeException('The directory '.$dir.' could not be created.'); } Loading history...
432
433			}
434
435			}
436
437			}
438
439			class CleanUpIterator extends \FilterIterator {
			0 ignored issues – show Coding Style Compatibility introduced 2015-11-21 01:52 UTC by Report Bug Copy Issue Report PSR1 recommends that each class should be in its own file to aid autoloaders. Having each class in a dedicated file usually plays nice with PSR autoloaders and is therefore a well established practice. If you use other autoloaders, you might not want to follow this rule. Loading history...
440
441			// Don't match index.html,files with zip extension or status logfiles.
442			public function accept() {
443			return ! preg_match( '/(index\.html\|.\.zip\|.-running)/', $this->current() );
444			}
445			}
446

humanmade / backupwordpress

GitHub Access Token became invalid

Pull Request — master (#983)

Path::get_home_path() C

Complexity

Size

Duplication

Importance

1. Pass all data via parameters

2. Create a class that maintains your state

Duplication Side-by-Side

Filter issues like