nextcloud / server

lib/private/Files/Config/UserMountCacheListener.php

Indentation +15 added lines, -15 removed lines

@@ -29,21 +29,21 @@
  * Listen to hooks and update the mount cache as needed
  */
 class UserMountCacheListener {
-	/**
-	 * @var IUserMountCache
-	 */
-	private $userMountCache;
+    /**
+     * @var IUserMountCache
+     */
+    private $userMountCache;
 
-	/**
-	 * UserMountCacheListener constructor.
-	 *
-	 * @param IUserMountCache $userMountCache
-	 */
-	public function __construct(IUserMountCache $userMountCache) {
-		$this->userMountCache = $userMountCache;
-	}
+    /**
+     * UserMountCacheListener constructor.
+     *
+     * @param IUserMountCache $userMountCache
+     */
+    public function __construct(IUserMountCache $userMountCache) {
+        $this->userMountCache = $userMountCache;
+    }
 
-	public function listen(Manager $manager) {
-		$manager->listen('\OC\User', 'postDelete', [$this->userMountCache, 'removeUserMounts']);
-	}
+    public function listen(Manager $manager) {
+        $manager->listen('\OC\User', 'postDelete', [$this->userMountCache, 'removeUserMounts']);
+    }
 }

lib/private/Files/Config/CachedMountInfo.php

Indentation +110 added lines, -110 removed lines

@@ -28,114 +28,114 @@
 use OCP\IUser;
 
 class CachedMountInfo implements ICachedMountInfo {
-	/**
-	 * @var IUser
-	 */
-	protected $user;
-
-	/**
-	 * @var int
-	 */
-	protected $storageId;
-
-	/**
-	 * @var int
-	 */
-	protected $rootId;
-
-	/**
-	 * @var string
-	 */
-	protected $mountPoint;
-
-	/**
-	 * @var int|null
-	 */
-	protected $mountId;
-
-	/**
-	 * @var string
-	 */
-	protected $rootInternalPath;
-
-	/**
-	 * CachedMountInfo constructor.
-	 *
-	 * @param IUser $user
-	 * @param int $storageId
-	 * @param int $rootId
-	 * @param string $mountPoint
-	 * @param int|null $mountId
-	 * @param string $rootInternalPath
-	 */
-	public function __construct(IUser $user, $storageId, $rootId, $mountPoint, $mountId = null, $rootInternalPath = '') {
-		$this->user = $user;
-		$this->storageId = $storageId;
-		$this->rootId = $rootId;
-		$this->mountPoint = $mountPoint;
-		$this->mountId = $mountId;
-		$this->rootInternalPath = $rootInternalPath;
-	}
-
-	/**
-	 * @return IUser
-	 */
-	public function getUser() {
-		return $this->user;
-	}
-
-	/**
-	 * @return int the numeric storage id of the mount
-	 */
-	public function getStorageId() {
-		return $this->storageId;
-	}
-
-	/**
-	 * @return int the fileid of the root of the mount
-	 */
-	public function getRootId() {
-		return $this->rootId;
-	}
-
-	/**
-	 * @return Node the root node of the mount
-	 */
-	public function getMountPointNode() {
-		// TODO injection etc
-		Filesystem::initMountPoints($this->getUser()->getUID());
-		$userNode = \OC::$server->getUserFolder($this->getUser()->getUID());
-		$nodes = $userNode->getParent()->getById($this->getRootId());
-		if (count($nodes) > 0) {
-			return $nodes[0];
-		} else {
-			return null;
-		}
-	}
-
-	/**
-	 * @return string the mount point of the mount for the user
-	 */
-	public function getMountPoint() {
-		return $this->mountPoint;
-	}
-
-	/**
-	 * Get the id of the configured mount
-	 *
-	 * @return int|null mount id or null if not applicable
-	 * @since 9.1.0
-	 */
-	public function getMountId() {
-		return $this->mountId;
-	}
-
-	/**
-	 * Get the internal path (within the storage) of the root of the mount
-	 *
-	 * @return string
-	 */
-	public function getRootInternalPath() {
-		return $this->rootInternalPath;
-	}
+    /**
+     * @var IUser
+     */
+    protected $user;
+
+    /**
+     * @var int
+     */
+    protected $storageId;
+
+    /**
+     * @var int
+     */
+    protected $rootId;
+
+    /**
+     * @var string
+     */
+    protected $mountPoint;
+
+    /**
+     * @var int|null
+     */
+    protected $mountId;
+
+    /**
+     * @var string
+     */
+    protected $rootInternalPath;
+
+    /**
+     * CachedMountInfo constructor.
+     *
+     * @param IUser $user
+     * @param int $storageId
+     * @param int $rootId
+     * @param string $mountPoint
+     * @param int|null $mountId
+     * @param string $rootInternalPath
+     */
+    public function __construct(IUser $user, $storageId, $rootId, $mountPoint, $mountId = null, $rootInternalPath = '') {
+        $this->user = $user;
+        $this->storageId = $storageId;
+        $this->rootId = $rootId;
+        $this->mountPoint = $mountPoint;
+        $this->mountId = $mountId;
+        $this->rootInternalPath = $rootInternalPath;
+    }
+
+    /**
+     * @return IUser
+     */
+    public function getUser() {
+        return $this->user;
+    }
+
+    /**
+     * @return int the numeric storage id of the mount
+     */
+    public function getStorageId() {
+        return $this->storageId;
+    }
+
+    /**
+     * @return int the fileid of the root of the mount
+     */
+    public function getRootId() {
+        return $this->rootId;
+    }
+
+    /**
+     * @return Node the root node of the mount
+     */
+    public function getMountPointNode() {
+        // TODO injection etc
+        Filesystem::initMountPoints($this->getUser()->getUID());
+        $userNode = \OC::$server->getUserFolder($this->getUser()->getUID());
+        $nodes = $userNode->getParent()->getById($this->getRootId());
+        if (count($nodes) > 0) {
+            return $nodes[0];
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * @return string the mount point of the mount for the user
+     */
+    public function getMountPoint() {
+        return $this->mountPoint;
+    }
+
+    /**
+     * Get the id of the configured mount
+     *
+     * @return int|null mount id or null if not applicable
+     * @since 9.1.0
+     */
+    public function getMountId() {
+        return $this->mountId;
+    }
+
+    /**
+     * Get the internal path (within the storage) of the root of the mount
+     *
+     * @return string
+     */
+    public function getRootInternalPath() {
+        return $this->rootInternalPath;
+    }
 }

lib/private/Files/ObjectStore/HomeObjectStoreStorage.php

Indentation +33 added lines, -33 removed lines

@@ -28,42 +28,42 @@
 
 class HomeObjectStoreStorage extends ObjectStoreStorage implements \OCP\Files\IHomeStorage {
 
-	/**
-	 * The home user storage requires a user object to create a unique storage id
-	 * @param array $params
-	 */
-	public function __construct($params) {
-		if ( ! isset($params['user']) || ! $params['user'] instanceof User) {
-			throw new \Exception('missing user object in parameters');
-		}
-		$this->user = $params['user'];
-		parent::__construct($params);
-	}
+    /**
+     * The home user storage requires a user object to create a unique storage id
+     * @param array $params
+     */
+    public function __construct($params) {
+        if ( ! isset($params['user']) || ! $params['user'] instanceof User) {
+            throw new \Exception('missing user object in parameters');
+        }
+        $this->user = $params['user'];
+        parent::__construct($params);
+    }
 
-	public function getId () {
-		return 'object::user:' . $this->user->getUID();
-	}
+    public function getId () {
+        return 'object::user:' . $this->user->getUID();
+    }
 
-	/**
-	 * get the owner of a path
-	 *
-	 * @param string $path The path to get the owner
-	 * @return false|string uid
-	 */
-	public function getOwner($path) {
-		if (is_object($this->user)) {
-			return $this->user->getUID();
-		}
-		return false;
-	}
+    /**
+     * get the owner of a path
+     *
+     * @param string $path The path to get the owner
+     * @return false|string uid
+     */
+    public function getOwner($path) {
+        if (is_object($this->user)) {
+            return $this->user->getUID();
+        }
+        return false;
+    }
 
-	/**
-	 * @param string $path, optional
-	 * @return \OC\User\User
-	 */
-	public function getUser($path = null) {
-		return $this->user;
-	}
+    /**
+     * @param string $path, optional
+     * @return \OC\User\User
+     */
+    public function getUser($path = null) {
+        return $this->user;
+    }
 
 
 }
\ No newline at end of file

Spacing +3 added lines, -3 removed lines

@@ -33,15 +33,15 @@
 	 * @param array $params
 	 */
 	public function __construct($params) {
-		if ( ! isset($params['user']) || ! $params['user'] instanceof User) {
+		if (!isset($params['user']) || !$params['user'] instanceof User) {
 			throw new \Exception('missing user object in parameters');
 		}
 		$this->user = $params['user'];
 		parent::__construct($params);
 	}
 
-	public function getId () {
-		return 'object::user:' . $this->user->getUID();
+	public function getId() {
+		return 'object::user:'.$this->user->getUID();
 	}
 
 	/**

lib/private/Files/ObjectStore/NoopScanner.php

Indentation +44 added lines, -44 removed lines

@@ -29,52 +29,52 @@
 
 class NoopScanner extends Scanner {
 
-	public function __construct(Storage $storage) {
-		//we don't need the storage, so do nothing here
-	}
+    public function __construct(Storage $storage) {
+        //we don't need the storage, so do nothing here
+    }
 
-	/**
-	 * scan a single file and store it in the cache
-	 *
-	 * @param string $file
-	 * @param int $reuseExisting
-	 * @param int $parentId
-	 * @param array|null $cacheData existing data in the cache for the file to be scanned
-	 * @return array an array of metadata of the scanned file
-	 */
-	public function scanFile($file, $reuseExisting = 0, $parentId = -1, $cacheData = null, $lock = true) {
-		return array();
-	}
+    /**
+     * scan a single file and store it in the cache
+     *
+     * @param string $file
+     * @param int $reuseExisting
+     * @param int $parentId
+     * @param array|null $cacheData existing data in the cache for the file to be scanned
+     * @return array an array of metadata of the scanned file
+     */
+    public function scanFile($file, $reuseExisting = 0, $parentId = -1, $cacheData = null, $lock = true) {
+        return array();
+    }
 
-	/**
-	 * scan a folder and all it's children
-	 *
-	 * @param string $path
-	 * @param bool $recursive
-	 * @param int $reuse
-	 * @return array with the meta data of the scanned file or folder
-	 */
-	public function scan($path, $recursive = self::SCAN_RECURSIVE, $reuse = -1, $lock = true) {
-		return array();
-	}
+    /**
+     * scan a folder and all it's children
+     *
+     * @param string $path
+     * @param bool $recursive
+     * @param int $reuse
+     * @return array with the meta data of the scanned file or folder
+     */
+    public function scan($path, $recursive = self::SCAN_RECURSIVE, $reuse = -1, $lock = true) {
+        return array();
+    }
 
-	/**
-	 * scan all the files and folders in a folder
-	 *
-	 * @param string $path
-	 * @param bool $recursive
-	 * @param int $reuse
-	 * @param array $folderData existing cache data for the folder to be scanned
-	 * @return int the size of the scanned folder or -1 if the size is unknown at this stage
-	 */
-	protected function scanChildren($path, $recursive = self::SCAN_RECURSIVE, $reuse = -1, $folderData = null, $lock = true) {
-		return 0;
-	}
+    /**
+     * scan all the files and folders in a folder
+     *
+     * @param string $path
+     * @param bool $recursive
+     * @param int $reuse
+     * @param array $folderData existing cache data for the folder to be scanned
+     * @return int the size of the scanned folder or -1 if the size is unknown at this stage
+     */
+    protected function scanChildren($path, $recursive = self::SCAN_RECURSIVE, $reuse = -1, $folderData = null, $lock = true) {
+        return 0;
+    }
 
-	/**
-	 * walk over any folders that are not fully scanned yet and scan them
-	 */
-	public function backgroundScan() {
-		//noop
-	}
+    /**
+     * walk over any folders that are not fully scanned yet and scan them
+     */
+    public function backgroundScan() {
+        //noop
+    }
 }

lib/private/Files/ObjectStore/Mapper.php

Indentation +19 added lines, -19 removed lines

@@ -31,25 +31,25 @@
  * Map a user to a bucket.
  */
 class Mapper {
-	/** @var IUser */
-	private $user;
+    /** @var IUser */
+    private $user;
 
-	/**
-	 * Mapper constructor.
-	 *
-	 * @param IUser $user
-	 */
-	public function __construct(IUser $user) {
-		$this->user = $user;
-	}
+    /**
+     * Mapper constructor.
+     *
+     * @param IUser $user
+     */
+    public function __construct(IUser $user) {
+        $this->user = $user;
+    }
 
-	/**
-	 * @param int $numBuckets
-	 * @return string
-	 */
-	public function getBucket($numBuckets = 64) {
-		$hash = md5($this->user->getUID());
-		$num = hexdec(substr($hash, 0, 4));
-		return (string)($num % $numBuckets);
-	}
+    /**
+     * @param int $numBuckets
+     * @return string
+     */
+    public function getBucket($numBuckets = 64) {
+        $hash = md5($this->user->getUID());
+        $num = hexdec(substr($hash, 0, 4));
+        return (string)($num % $numBuckets);
+    }
 }

Spacing +1 added lines, -1 removed lines

@@ -50,6 +50,6 @@
 	public function getBucket($numBuckets = 64) {
 		$hash = md5($this->user->getUID());
 		$num = hexdec(substr($hash, 0, 4));
-		return (string)($num % $numBuckets);
+		return (string) ($num % $numBuckets);
 	}
 }

lib/private/Files/Type/Detection.php

Spacing +9 added lines, -9 removed lines

@@ -102,7 +102,7 @@ 
 
 		// Update the alternative mimetypes to avoid having to look them up each time.
 		foreach ($this->mimetypes as $mimeType) {
-			$this->secureMimeTypes[$mimeType[0]] = isset($mimeType[1]) ? $mimeType[1]: $mimeType[0];
+			$this->secureMimeTypes[$mimeType[0]] = isset($mimeType[1]) ? $mimeType[1] : $mimeType[0];
 		}
 	}
 
@@ -114,10 +114,10 @@ 
 			return;
 		}
 
-		$this->mimeTypeAlias = json_decode(file_get_contents($this->defaultConfigDir . '/mimetypealiases.dist.json'), true);
+		$this->mimeTypeAlias = json_decode(file_get_contents($this->defaultConfigDir.'/mimetypealiases.dist.json'), true);
 
-		if (file_exists($this->customConfigDir . '/mimetypealiases.json')) {
-			$custom = json_decode(file_get_contents($this->customConfigDir . '/mimetypealiases.json'), true);
+		if (file_exists($this->customConfigDir.'/mimetypealiases.json')) {
+			$custom = json_decode(file_get_contents($this->customConfigDir.'/mimetypealiases.json'), true);
 			$this->mimeTypeAlias = array_merge($this->mimeTypeAlias, $custom);
 		}
 	}
@@ -138,11 +138,11 @@ 
 			return;
 		}
 
-		$mimetypeMapping = json_decode(file_get_contents($this->defaultConfigDir . '/mimetypemapping.dist.json'), true);
+		$mimetypeMapping = json_decode(file_get_contents($this->defaultConfigDir.'/mimetypemapping.dist.json'), true);
 
 		//Check if need to load custom mappings
-		if (file_exists($this->customConfigDir . '/mimetypemapping.json')) {
-			$custom = json_decode(file_get_contents($this->customConfigDir . '/mimetypemapping.json'), true);
+		if (file_exists($this->customConfigDir.'/mimetypemapping.json')) {
+			$custom = json_decode(file_get_contents($this->customConfigDir.'/mimetypemapping.json'), true);
 			$mimetypeMapping = array_merge($mimetypeMapping, $custom);
 		}
 
@@ -306,7 +306,7 @@ 
 
 		// Icon exists?
 		try {
-			$this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/' . $icon . '.svg');
+			$this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/'.$icon.'.svg');
 			return $this->mimetypeIcons[$mimetype];
 		} catch (\RuntimeException $e) {
 			// Specified image not found
@@ -315,7 +315,7 @@ 
 		// Try only the first part of the filetype
 		$mimePart = substr($icon, 0, strpos($icon, '-'));
 		try {
-			$this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/' . $mimePart . '.svg');
+			$this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/'.$mimePart.'.svg');
 			return $this->mimetypeIcons[$mimetype];
 		} catch (\RuntimeException $e) {
 			// Image for the first part of the mimetype not found

Indentation +287 added lines, -287 removed lines

@@ -41,291 +41,291 @@
  * @package OC\Files\Type
  */
 class Detection implements IMimeTypeDetector {
-	protected $mimetypes = [];
-	protected $secureMimeTypes = [];
-
-	protected $mimetypeIcons = [];
-	/** @var string[] */
-	protected $mimeTypeAlias = [];
-
-	/** @var IURLGenerator */
-	private $urlGenerator;
-
-	/** @var string */
-	private $customConfigDir;
-
-	/** @var string */
-	private $defaultConfigDir;
-
-	/**
-	 * @param IURLGenerator $urlGenerator
-	 * @param string $customConfigDir
-	 * @param string $defaultConfigDir
-	 */
-	public function __construct(IURLGenerator $urlGenerator,
-								$customConfigDir,
-								$defaultConfigDir) {
-		$this->urlGenerator = $urlGenerator;
-		$this->customConfigDir = $customConfigDir;
-		$this->defaultConfigDir = $defaultConfigDir;
-	}
-
-	/**
-	 * Add an extension -> mimetype mapping
-	 *
-	 * $mimetype is the assumed correct mime type
-	 * The optional $secureMimeType is an alternative to send to send
-	 * to avoid potential XSS.
-	 *
-	 * @param string $extension
-	 * @param string $mimetype
-	 * @param string|null $secureMimeType
-	 */
-	public function registerType($extension,
-								 $mimetype,
-								 $secureMimeType = null) {
-		$this->mimetypes[$extension] = array($mimetype, $secureMimeType);
-		$this->secureMimeTypes[$mimetype] = $secureMimeType ?: $mimetype;
-	}
-
-	/**
-	 * Add an array of extension -> mimetype mappings
-	 *
-	 * The mimetype value is in itself an array where the first index is
-	 * the assumed correct mimetype and the second is either a secure alternative
-	 * or null if the correct is considered secure.
-	 *
-	 * @param array $types
-	 */
-	public function registerTypeArray($types) {
-		$this->mimetypes = array_merge($this->mimetypes, $types);
-
-		// Update the alternative mimetypes to avoid having to look them up each time.
-		foreach ($this->mimetypes as $mimeType) {
-			$this->secureMimeTypes[$mimeType[0]] = isset($mimeType[1]) ? $mimeType[1]: $mimeType[0];
-		}
-	}
-
-	/**
-	 * Add the mimetype aliases if they are not yet present
-	 */
-	private function loadAliases() {
-		if (!empty($this->mimeTypeAlias)) {
-			return;
-		}
-
-		$this->mimeTypeAlias = json_decode(file_get_contents($this->defaultConfigDir . '/mimetypealiases.dist.json'), true);
-
-		if (file_exists($this->customConfigDir . '/mimetypealiases.json')) {
-			$custom = json_decode(file_get_contents($this->customConfigDir . '/mimetypealiases.json'), true);
-			$this->mimeTypeAlias = array_merge($this->mimeTypeAlias, $custom);
-		}
-	}
-
-	/**
-	 * @return string[]
-	 */
-	public function getAllAliases() {
-		$this->loadAliases();
-		return $this->mimeTypeAlias;
-	}
-
-	/**
-	 * Add mimetype mappings if they are not yet present
-	 */
-	private function loadMappings() {
-		if (!empty($this->mimetypes)) {
-			return;
-		}
-
-		$mimetypeMapping = json_decode(file_get_contents($this->defaultConfigDir . '/mimetypemapping.dist.json'), true);
-
-		//Check if need to load custom mappings
-		if (file_exists($this->customConfigDir . '/mimetypemapping.json')) {
-			$custom = json_decode(file_get_contents($this->customConfigDir . '/mimetypemapping.json'), true);
-			$mimetypeMapping = array_merge($mimetypeMapping, $custom);
-		}
-
-		$this->registerTypeArray($mimetypeMapping);
-	}
-
-	/**
-	 * @return array
-	 */
-	public function getAllMappings() {
-		$this->loadMappings();
-		return $this->mimetypes;
-	}
-
-	/**
-	 * detect mimetype only based on filename, content of file is not used
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	public function detectPath($path) {
-		$this->loadMappings();
-
-		$fileName = basename($path);
-
-		// remove leading dot on hidden files with a file extension
-		$fileName = ltrim($fileName, '.');
-
-		// note: leading dot doesn't qualify as extension
-		if (strpos($fileName, '.') > 0) {
-
-			// remove versioning extension: name.v1508946057 and transfer extension: name.ocTransferId2057600214.part
-			$fileName = preg_replace('!((\.v\d+)|((.ocTransferId\d+)?.part))$!', '', $fileName);
-
-			//try to guess the type by the file extension
-			$extension = strtolower(strrchr($fileName, '.'));
-			$extension = substr($extension, 1); //remove leading .
-			return (isset($this->mimetypes[$extension]) && isset($this->mimetypes[$extension][0]))
-				? $this->mimetypes[$extension][0]
-				: 'application/octet-stream';
-		} else {
-			return 'application/octet-stream';
-		}
-	}
-
-	/**
-	 * detect mimetype based on both filename and content
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	public function detect($path) {
-		$this->loadMappings();
-
-		if (@is_dir($path)) {
-			// directories are easy
-			return "httpd/unix-directory";
-		}
-
-		$mimeType = $this->detectPath($path);
-
-		if ($mimeType === 'application/octet-stream' and function_exists('finfo_open')
-			and function_exists('finfo_file') and $finfo = finfo_open(FILEINFO_MIME)
-		) {
-			$info = @strtolower(finfo_file($finfo, $path));
-			finfo_close($finfo);
-			if ($info) {
-				$mimeType = strpos($info, ';') !== false ? substr($info, 0, strpos($info, ';')) : $info;
-				return empty($mimeType) ? 'application/octet-stream' : $mimeType;
-			}
-
-		}
-		$isWrapped = (strpos($path, '://') !== false) and (substr($path, 0, 7) === 'file://');
-		if (!$isWrapped and $mimeType === 'application/octet-stream' && function_exists("mime_content_type")) {
-			// use mime magic extension if available
-			$mimeType = mime_content_type($path);
-		}
-		if (!$isWrapped and $mimeType === 'application/octet-stream' && \OC_Helper::canExecute("file")) {
-			// it looks like we have a 'file' command,
-			// lets see if it does have mime support
-			$path = escapeshellarg($path);
-			$fp = popen("file -b --mime-type $path 2>/dev/null", "r");
-			$reply = fgets($fp);
-			pclose($fp);
-
-			//trim the newline
-			$mimeType = trim($reply);
-
-			if (empty($mimeType)) {
-				$mimeType = 'application/octet-stream';
-			}
-
-		}
-		return $mimeType;
-	}
-
-	/**
-	 * detect mimetype based on the content of a string
-	 *
-	 * @param string $data
-	 * @return string
-	 */
-	public function detectString($data) {
-		if (function_exists('finfo_open') and function_exists('finfo_file')) {
-			$finfo = finfo_open(FILEINFO_MIME);
-			$info = finfo_buffer($finfo, $data);
-			return strpos($info, ';') !== false ? substr($info, 0, strpos($info, ';')) : $info;
-		} else {
-			$tmpFile = \OC::$server->getTempManager()->getTemporaryFile();
-			$fh = fopen($tmpFile, 'wb');
-			fwrite($fh, $data, 8024);
-			fclose($fh);
-			$mime = $this->detect($tmpFile);
-			unset($tmpFile);
-			return $mime;
-		}
-	}
-
-	/**
-	 * Get a secure mimetype that won't expose potential XSS.
-	 *
-	 * @param string $mimeType
-	 * @return string
-	 */
-	public function getSecureMimeType($mimeType) {
-		$this->loadMappings();
-
-		return isset($this->secureMimeTypes[$mimeType])
-			? $this->secureMimeTypes[$mimeType]
-			: 'application/octet-stream';
-	}
-
-	/**
-	 * Get path to the icon of a file type
-	 * @param string $mimetype the MIME type
-	 * @return string the url
-	 */
-	public function mimeTypeIcon($mimetype) {
-		$this->loadAliases();
-
-		while (isset($this->mimeTypeAlias[$mimetype])) {
-			$mimetype = $this->mimeTypeAlias[$mimetype];
-		}
-		if (isset($this->mimetypeIcons[$mimetype])) {
-			return $this->mimetypeIcons[$mimetype];
-		}
-
-		// Replace slash and backslash with a minus
-		$icon = str_replace('/', '-', $mimetype);
-		$icon = str_replace('\\', '-', $icon);
-
-		// Is it a dir?
-		if ($mimetype === 'dir') {
-			$this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/folder.svg');
-			return $this->mimetypeIcons[$mimetype];
-		}
-		if ($mimetype === 'dir-shared') {
-			$this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/folder-shared.svg');
-			return $this->mimetypeIcons[$mimetype];
-		}
-		if ($mimetype === 'dir-external') {
-			$this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/folder-external.svg');
-			return $this->mimetypeIcons[$mimetype];
-		}
-
-		// Icon exists?
-		try {
-			$this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/' . $icon . '.svg');
-			return $this->mimetypeIcons[$mimetype];
-		} catch (\RuntimeException $e) {
-			// Specified image not found
-		}
-
-		// Try only the first part of the filetype
-		$mimePart = substr($icon, 0, strpos($icon, '-'));
-		try {
-			$this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/' . $mimePart . '.svg');
-			return $this->mimetypeIcons[$mimetype];
-		} catch (\RuntimeException $e) {
-			// Image for the first part of the mimetype not found
-		}
-
-		$this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/file.svg');
-		return $this->mimetypeIcons[$mimetype];
-	}
+    protected $mimetypes = [];
+    protected $secureMimeTypes = [];
+
+    protected $mimetypeIcons = [];
+    /** @var string[] */
+    protected $mimeTypeAlias = [];
+
+    /** @var IURLGenerator */
+    private $urlGenerator;
+
+    /** @var string */
+    private $customConfigDir;
+
+    /** @var string */
+    private $defaultConfigDir;
+
+    /**
+     * @param IURLGenerator $urlGenerator
+     * @param string $customConfigDir
+     * @param string $defaultConfigDir
+     */
+    public function __construct(IURLGenerator $urlGenerator,
+                                $customConfigDir,
+                                $defaultConfigDir) {
+        $this->urlGenerator = $urlGenerator;
+        $this->customConfigDir = $customConfigDir;
+        $this->defaultConfigDir = $defaultConfigDir;
+    }
+
+    /**
+     * Add an extension -> mimetype mapping
+     *
+     * $mimetype is the assumed correct mime type
+     * The optional $secureMimeType is an alternative to send to send
+     * to avoid potential XSS.
+     *
+     * @param string $extension
+     * @param string $mimetype
+     * @param string|null $secureMimeType
+     */
+    public function registerType($extension,
+                                    $mimetype,
+                                    $secureMimeType = null) {
+        $this->mimetypes[$extension] = array($mimetype, $secureMimeType);
+        $this->secureMimeTypes[$mimetype] = $secureMimeType ?: $mimetype;
+    }
+
+    /**
+     * Add an array of extension -> mimetype mappings
+     *
+     * The mimetype value is in itself an array where the first index is
+     * the assumed correct mimetype and the second is either a secure alternative
+     * or null if the correct is considered secure.
+     *
+     * @param array $types
+     */
+    public function registerTypeArray($types) {
+        $this->mimetypes = array_merge($this->mimetypes, $types);
+
+        // Update the alternative mimetypes to avoid having to look them up each time.
+        foreach ($this->mimetypes as $mimeType) {
+            $this->secureMimeTypes[$mimeType[0]] = isset($mimeType[1]) ? $mimeType[1]: $mimeType[0];
+        }
+    }
+
+    /**
+     * Add the mimetype aliases if they are not yet present
+     */
+    private function loadAliases() {
+        if (!empty($this->mimeTypeAlias)) {
+            return;
+        }
+
+        $this->mimeTypeAlias = json_decode(file_get_contents($this->defaultConfigDir . '/mimetypealiases.dist.json'), true);
+
+        if (file_exists($this->customConfigDir . '/mimetypealiases.json')) {
+            $custom = json_decode(file_get_contents($this->customConfigDir . '/mimetypealiases.json'), true);
+            $this->mimeTypeAlias = array_merge($this->mimeTypeAlias, $custom);
+        }
+    }
+
+    /**
+     * @return string[]
+     */
+    public function getAllAliases() {
+        $this->loadAliases();
+        return $this->mimeTypeAlias;
+    }
+
+    /**
+     * Add mimetype mappings if they are not yet present
+     */
+    private function loadMappings() {
+        if (!empty($this->mimetypes)) {
+            return;
+        }
+
+        $mimetypeMapping = json_decode(file_get_contents($this->defaultConfigDir . '/mimetypemapping.dist.json'), true);
+
+        //Check if need to load custom mappings
+        if (file_exists($this->customConfigDir . '/mimetypemapping.json')) {
+            $custom = json_decode(file_get_contents($this->customConfigDir . '/mimetypemapping.json'), true);
+            $mimetypeMapping = array_merge($mimetypeMapping, $custom);
+        }
+
+        $this->registerTypeArray($mimetypeMapping);
+    }
+
+    /**
+     * @return array
+     */
+    public function getAllMappings() {
+        $this->loadMappings();
+        return $this->mimetypes;
+    }
+
+    /**
+     * detect mimetype only based on filename, content of file is not used
+     *
+     * @param string $path
+     * @return string
+     */
+    public function detectPath($path) {
+        $this->loadMappings();
+
+        $fileName = basename($path);
+
+        // remove leading dot on hidden files with a file extension
+        $fileName = ltrim($fileName, '.');
+
+        // note: leading dot doesn't qualify as extension
+        if (strpos($fileName, '.') > 0) {
+
+            // remove versioning extension: name.v1508946057 and transfer extension: name.ocTransferId2057600214.part
+            $fileName = preg_replace('!((\.v\d+)|((.ocTransferId\d+)?.part))$!', '', $fileName);
+
+            //try to guess the type by the file extension
+            $extension = strtolower(strrchr($fileName, '.'));
+            $extension = substr($extension, 1); //remove leading .
+            return (isset($this->mimetypes[$extension]) && isset($this->mimetypes[$extension][0]))
+                ? $this->mimetypes[$extension][0]
+                : 'application/octet-stream';
+        } else {
+            return 'application/octet-stream';
+        }
+    }
+
+    /**
+     * detect mimetype based on both filename and content
+     *
+     * @param string $path
+     * @return string
+     */
+    public function detect($path) {
+        $this->loadMappings();
+
+        if (@is_dir($path)) {
+            // directories are easy
+            return "httpd/unix-directory";
+        }
+
+        $mimeType = $this->detectPath($path);
+
+        if ($mimeType === 'application/octet-stream' and function_exists('finfo_open')
+            and function_exists('finfo_file') and $finfo = finfo_open(FILEINFO_MIME)
+        ) {
+            $info = @strtolower(finfo_file($finfo, $path));
+            finfo_close($finfo);
+            if ($info) {
+                $mimeType = strpos($info, ';') !== false ? substr($info, 0, strpos($info, ';')) : $info;
+                return empty($mimeType) ? 'application/octet-stream' : $mimeType;
+            }
+
+        }
+        $isWrapped = (strpos($path, '://') !== false) and (substr($path, 0, 7) === 'file://');
+        if (!$isWrapped and $mimeType === 'application/octet-stream' && function_exists("mime_content_type")) {
+            // use mime magic extension if available
+            $mimeType = mime_content_type($path);
+        }
+        if (!$isWrapped and $mimeType === 'application/octet-stream' && \OC_Helper::canExecute("file")) {
+            // it looks like we have a 'file' command,
+            // lets see if it does have mime support
+            $path = escapeshellarg($path);
+            $fp = popen("file -b --mime-type $path 2>/dev/null", "r");
+            $reply = fgets($fp);
+            pclose($fp);
+
+            //trim the newline
+            $mimeType = trim($reply);
+
+            if (empty($mimeType)) {
+                $mimeType = 'application/octet-stream';
+            }
+
+        }
+        return $mimeType;
+    }
+
+    /**
+     * detect mimetype based on the content of a string
+     *
+     * @param string $data
+     * @return string
+     */
+    public function detectString($data) {
+        if (function_exists('finfo_open') and function_exists('finfo_file')) {
+            $finfo = finfo_open(FILEINFO_MIME);
+            $info = finfo_buffer($finfo, $data);
+            return strpos($info, ';') !== false ? substr($info, 0, strpos($info, ';')) : $info;
+        } else {
+            $tmpFile = \OC::$server->getTempManager()->getTemporaryFile();
+            $fh = fopen($tmpFile, 'wb');
+            fwrite($fh, $data, 8024);
+            fclose($fh);
+            $mime = $this->detect($tmpFile);
+            unset($tmpFile);
+            return $mime;
+        }
+    }
+
+    /**
+     * Get a secure mimetype that won't expose potential XSS.
+     *
+     * @param string $mimeType
+     * @return string
+     */
+    public function getSecureMimeType($mimeType) {
+        $this->loadMappings();
+
+        return isset($this->secureMimeTypes[$mimeType])
+            ? $this->secureMimeTypes[$mimeType]
+            : 'application/octet-stream';
+    }
+
+    /**
+     * Get path to the icon of a file type
+     * @param string $mimetype the MIME type
+     * @return string the url
+     */
+    public function mimeTypeIcon($mimetype) {
+        $this->loadAliases();
+
+        while (isset($this->mimeTypeAlias[$mimetype])) {
+            $mimetype = $this->mimeTypeAlias[$mimetype];
+        }
+        if (isset($this->mimetypeIcons[$mimetype])) {
+            return $this->mimetypeIcons[$mimetype];
+        }
+
+        // Replace slash and backslash with a minus
+        $icon = str_replace('/', '-', $mimetype);
+        $icon = str_replace('\\', '-', $icon);
+
+        // Is it a dir?
+        if ($mimetype === 'dir') {
+            $this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/folder.svg');
+            return $this->mimetypeIcons[$mimetype];
+        }
+        if ($mimetype === 'dir-shared') {
+            $this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/folder-shared.svg');
+            return $this->mimetypeIcons[$mimetype];
+        }
+        if ($mimetype === 'dir-external') {
+            $this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/folder-external.svg');
+            return $this->mimetypeIcons[$mimetype];
+        }
+
+        // Icon exists?
+        try {
+            $this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/' . $icon . '.svg');
+            return $this->mimetypeIcons[$mimetype];
+        } catch (\RuntimeException $e) {
+            // Specified image not found
+        }
+
+        // Try only the first part of the filetype
+        $mimePart = substr($icon, 0, strpos($icon, '-'));
+        try {
+            $this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/' . $mimePart . '.svg');
+            return $this->mimetypeIcons[$mimetype];
+        } catch (\RuntimeException $e) {
+            // Image for the first part of the mimetype not found
+        }
+
+        $this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/file.svg');
+        return $this->mimetypeIcons[$mimetype];
+    }
 }

lib/private/Files/Type/TemplateManager.php

Indentation +31 added lines, -31 removed lines

@@ -25,38 +25,38 @@
 namespace OC\Files\Type;
 
 class TemplateManager {
-	protected $templates = array();
+    protected $templates = array();
 
-	public function registerTemplate($mimetype, $path) {
-		$this->templates[$mimetype] = $path;
-	}
+    public function registerTemplate($mimetype, $path) {
+        $this->templates[$mimetype] = $path;
+    }
 
-	/**
-	 * get the path of the template for a mimetype
-	 *
-	 * @param string $mimetype
-	 * @return string|null
-	 */
-	public function getTemplatePath($mimetype) {
-		if (isset($this->templates[$mimetype])) {
-			return $this->templates[$mimetype];
-		} else {
-			return null;
-		}
-	}
+    /**
+     * get the path of the template for a mimetype
+     *
+     * @param string $mimetype
+     * @return string|null
+     */
+    public function getTemplatePath($mimetype) {
+        if (isset($this->templates[$mimetype])) {
+            return $this->templates[$mimetype];
+        } else {
+            return null;
+        }
+    }
 
-	/**
-	 * get the template content for a mimetype
-	 *
-	 * @param string $mimetype
-	 * @return string
-	 */
-	public function getTemplate($mimetype) {
-		$path = $this->getTemplatePath($mimetype);
-		if ($path) {
-			return file_get_contents($path);
-		} else {
-			return '';
-		}
-	}
+    /**
+     * get the template content for a mimetype
+     *
+     * @param string $mimetype
+     * @return string
+     */
+    public function getTemplate($mimetype) {
+        $path = $this->getTemplatePath($mimetype);
+        if ($path) {
+            return file_get_contents($path);
+        } else {
+            return '';
+        }
+    }
 }

lib/private/Files/SimpleFS/SimpleFile.php

Spacing +1 added lines, -1 removed lines

@@ -26,7 +26,7 @@
 use OCP\Files\NotPermittedException;
 use OCP\Files\SimpleFS\ISimpleFile;
 
-class SimpleFile implements ISimpleFile  {
+class SimpleFile implements ISimpleFile {
 
 	/** @var File $file */
 	private $file;

Indentation +139 added lines, -139 removed lines

@@ -29,144 +29,144 @@
 
 class SimpleFile implements ISimpleFile  {
 
-	/** @var File $file */
-	private $file;
-
-	/**
-	 * File constructor.
-	 *
-	 * @param File $file
-	 */
-	public function __construct(File $file) {
-		$this->file = $file;
-	}
-
-	/**
-	 * Get the name
-	 *
-	 * @return string
-	 */
-	public function getName() {
-		return $this->file->getName();
-	}
-
-	/**
-	 * Get the size in bytes
-	 *
-	 * @return int
-	 */
-	public function getSize() {
-		return $this->file->getSize();
-	}
-
-	/**
-	 * Get the ETag
-	 *
-	 * @return string
-	 */
-	public function getETag() {
-		return $this->file->getEtag();
-	}
-
-	/**
-	 * Get the last modification time
-	 *
-	 * @return int
-	 */
-	public function getMTime() {
-		return $this->file->getMTime();
-	}
-
-	/**
-	 * Get the content
-	 *
-	 * @throws NotPermittedException
-	 * @throws NotFoundException
-	 * @return string
-	 */
-	public function getContent() {
-		$result = $this->file->getContent();
-
-		if ($result === false) {
-			$this->checkFile();
-		}
-
-		return $result;
-	}
-
-	/**
-	 * Overwrite the file
-	 *
-	 * @param string|resource $data
-	 * @throws NotPermittedException
-	 */
-	public function putContent($data) {
-		$this->file->putContent($data);
-	}
-
-	/**
-	 * Sometimes there are some issues with the AppData. Most of them are from
-	 * user error. But we should handle them gracefull anyway.
-	 *
-	 * If for some reason the current file can't be found. We remove it.
-	 * Then traverse up and check all folders if they exists. This so that the
-	 * next request will have a valid appdata structure again.
-	 *
-	 * @throws NotFoundException
-	 */
-	private function checkFile() {
-		$cur = $this->file;
-
-		while ($cur->stat() === false) {
-			$parent = $cur->getParent();
-			$cur->delete();
-			$cur = $parent;
-		}
-
-		if ($cur !== $this->file) {
-			throw new NotFoundException('File does not exist');
-		}
-	}
-
-
-	/**
-	 * Delete the file
-	 *
-	 * @throws NotPermittedException
-	 */
-	public function delete() {
-		$this->file->delete();
-	}
-
-	/**
-	 * Get the MimeType
-	 *
-	 * @return string
-	 */
-	public function getMimeType() {
-		return $this->file->getMimeType();
-	}
-
-	/**
-	 * Open the file as stream for reading, resulting resource can be operated as stream like the result from php's own fopen
-	 *
-	 * @return resource
-	 * @throws \OCP\Files\NotPermittedException
-	 * @since 14.0.0
-	 */
-	public function read() {
-		return $this->file->fopen('r');
-	}
-
-	/**
-	 * Open the file as stream for writing, resulting resource can be operated as stream like the result from php's own fopen
-	 *
-	 * @return resource
-	 * @throws \OCP\Files\NotPermittedException
-	 * @since 14.0.0
-	 */
-	public function write() {
-		return $this->file->fopen('w');
-	}
+    /** @var File $file */
+    private $file;
+
+    /**
+     * File constructor.
+     *
+     * @param File $file
+     */
+    public function __construct(File $file) {
+        $this->file = $file;
+    }
+
+    /**
+     * Get the name
+     *
+     * @return string
+     */
+    public function getName() {
+        return $this->file->getName();
+    }
+
+    /**
+     * Get the size in bytes
+     *
+     * @return int
+     */
+    public function getSize() {
+        return $this->file->getSize();
+    }
+
+    /**
+     * Get the ETag
+     *
+     * @return string
+     */
+    public function getETag() {
+        return $this->file->getEtag();
+    }
+
+    /**
+     * Get the last modification time
+     *
+     * @return int
+     */
+    public function getMTime() {
+        return $this->file->getMTime();
+    }
+
+    /**
+     * Get the content
+     *
+     * @throws NotPermittedException
+     * @throws NotFoundException
+     * @return string
+     */
+    public function getContent() {
+        $result = $this->file->getContent();
+
+        if ($result === false) {
+            $this->checkFile();
+        }
+
+        return $result;
+    }
+
+    /**
+     * Overwrite the file
+     *
+     * @param string|resource $data
+     * @throws NotPermittedException
+     */
+    public function putContent($data) {
+        $this->file->putContent($data);
+    }
+
+    /**
+     * Sometimes there are some issues with the AppData. Most of them are from
+     * user error. But we should handle them gracefull anyway.
+     *
+     * If for some reason the current file can't be found. We remove it.
+     * Then traverse up and check all folders if they exists. This so that the
+     * next request will have a valid appdata structure again.
+     *
+     * @throws NotFoundException
+     */
+    private function checkFile() {
+        $cur = $this->file;
+
+        while ($cur->stat() === false) {
+            $parent = $cur->getParent();
+            $cur->delete();
+            $cur = $parent;
+        }
+
+        if ($cur !== $this->file) {
+            throw new NotFoundException('File does not exist');
+        }
+    }
+
+
+    /**
+     * Delete the file
+     *
+     * @throws NotPermittedException
+     */
+    public function delete() {
+        $this->file->delete();
+    }
+
+    /**
+     * Get the MimeType
+     *
+     * @return string
+     */
+    public function getMimeType() {
+        return $this->file->getMimeType();
+    }
+
+    /**
+     * Open the file as stream for reading, resulting resource can be operated as stream like the result from php's own fopen
+     *
+     * @return resource
+     * @throws \OCP\Files\NotPermittedException
+     * @since 14.0.0
+     */
+    public function read() {
+        return $this->file->fopen('r');
+    }
+
+    /**
+     * Open the file as stream for writing, resulting resource can be operated as stream like the result from php's own fopen
+     *
+     * @return resource
+     * @throws \OCP\Files\NotPermittedException
+     * @since 14.0.0
+     */
+    public function write() {
+        return $this->file->fopen('w');
+    }
 
 }

lib/private/Files/SimpleFS/SimpleFolder.php

Indentation +41 added lines, -41 removed lines

@@ -30,58 +30,58 @@
 
 class SimpleFolder implements ISimpleFolder   {
 
-	/** @var Folder */
-	private $folder;
+    /** @var Folder */
+    private $folder;
 
-	/**
-	 * Folder constructor.
-	 *
-	 * @param Folder $folder
-	 */
-	public function __construct(Folder $folder) {
-		$this->folder = $folder;
-	}
+    /**
+     * Folder constructor.
+     *
+     * @param Folder $folder
+     */
+    public function __construct(Folder $folder) {
+        $this->folder = $folder;
+    }
 
-	public function getName() {
-		return $this->folder->getName();
-	}
+    public function getName() {
+        return $this->folder->getName();
+    }
 
-	public function getDirectoryListing() {
-		$listing = $this->folder->getDirectoryListing();
+    public function getDirectoryListing() {
+        $listing = $this->folder->getDirectoryListing();
 
-		$fileListing = array_map(function(Node $file) {
-			if ($file instanceof File) {
-				return new SimpleFile($file);
-			}
-			return null;
-		}, $listing);
+        $fileListing = array_map(function(Node $file) {
+            if ($file instanceof File) {
+                return new SimpleFile($file);
+            }
+            return null;
+        }, $listing);
 
-		$fileListing = array_filter($fileListing);
+        $fileListing = array_filter($fileListing);
 
-		return array_values($fileListing);
-	}
+        return array_values($fileListing);
+    }
 
-	public function delete() {
-		$this->folder->delete();
-	}
+    public function delete() {
+        $this->folder->delete();
+    }
 
-	public function fileExists($name) {
-		return $this->folder->nodeExists($name);
-	}
+    public function fileExists($name) {
+        return $this->folder->nodeExists($name);
+    }
 
-	public function getFile($name) {
-		$file = $this->folder->get($name);
+    public function getFile($name) {
+        $file = $this->folder->get($name);
 
-		if (!($file instanceof File)) {
-			throw new NotFoundException();
-		}
+        if (!($file instanceof File)) {
+            throw new NotFoundException();
+        }
 
-		return new SimpleFile($file);
-	}
+        return new SimpleFile($file);
+    }
 
-	public function newFile($name) {
-		$file = $this->folder->newFile($name);
+    public function newFile($name) {
+        $file = $this->folder->newFile($name);
 
-		return new SimpleFile($file);
-	}
+        return new SimpleFile($file);
+    }
 }

Spacing +1 added lines, -1 removed lines

@@ -28,7 +28,7 @@
 use OCP\Files\NotFoundException;
 use OCP\Files\SimpleFS\ISimpleFolder;
 
-class SimpleFolder implements ISimpleFolder   {
+class SimpleFolder implements ISimpleFolder {
 
 	/** @var Folder */
 	private $folder;