Merge branch 'master' into master-sqlserver

8 files changed, 603 insertions, 9 deletions

diff --git a/lib/files/cache/scanner.php b/lib/files/cache/scanner.php
index 8d504af6163..5a9a119458e 100644
--- a/lib/files/cache/scanner.php
+++ b/lib/files/cache/scanner.php
@@ -97,7 +97,7 @@ class Scanner {
 		if ($this->storage->is_dir($path) && ($dh = $this->storage->opendir($path))) {
 			\OC_DB::beginTransaction();
 			while ($file = readdir($dh)) {
-				if ($file !== '.' and $file !== '..') {
+				if (!$this->isIgnoredFile($file)) {
 					$child = ($path) ? $path . '/' . $file : $file;
 					$data = $this->scanFile($child);
 					if ($data) {
@@ -133,12 +133,28 @@ class Scanner {
 		}
 		return $size;
 	}
+	
+	/**
+	 * @brief check if the file should be ignored when scanning
+	 * NOTE: files with a '.part' extension are ignored as well!
+	 *       prevents unfinished put requests to be scanned
+	 * @param String $file
+	 * @return boolean
+	 */
+	private function isIgnoredFile($file) {
+		if ($file === '.' || $file === '..'
+		 || pathinfo($file,PATHINFO_EXTENSION) === 'part')
+		{
+			return true;
+		}
+		return false;
+	}
 
 	/**
 	 * walk over any folders that are not fully scanned yet and scan them
 	 */
 	public function backgroundScan() {
-		while ($path = $this->cache->getIncomplete()) {
+		while (($path = $this->cache->getIncomplete()) !== false) {
 			$this->scan($path);
 			$this->cache->correctFolderSize($path);
 		}
diff --git a/lib/files/filesystem.php b/lib/files/filesystem.php
index 71bf3d8708d..a0c3c4b9b75 100644
--- a/lib/files/filesystem.php
+++ b/lib/files/filesystem.php
@@ -190,14 +190,14 @@ class Filesystem {
 		}
 	}
 
-	static public function init($root) {
+	static public function init($user, $root) {
 		if (self::$defaultInstance) {
 			return false;
 		}
 		self::$defaultInstance = new View($root);
 
 		//load custom mount config
-		self::initMountPoints();
+		self::initMountPoints($user);
 
 		self::$loaded = true;
 
diff --git a/lib/files/mapper.php b/lib/files/mapper.php
new file mode 100644
index 00000000000..71b665e49bb
--- /dev/null
+++ b/lib/files/mapper.php
@@ -0,0 +1,216 @@
+<?php
+
+namespace OC\Files;
+
+/**
+ * class Mapper is responsible to translate logical paths to physical paths and reverse
+ */
+class Mapper
+{
+	/**
+	 * @param string $logicPath
+	 * @param bool $create indicates if the generated physical name shall be stored in the database or not
+	 * @return string the physical path
+	 */
+	public function logicToPhysical($logicPath, $create) {
+		$physicalPath = $this->resolveLogicPath($logicPath);
+		if ($physicalPath !== null) {
+			return $physicalPath;
+		}
+
+		return $this->create($logicPath, $create);
+	}
+
+	/**
+	 * @param string $physicalPath
+	 * @return string|null
+	 */
+	public function physicalToLogic($physicalPath) {
+		$logicPath = $this->resolvePhysicalPath($physicalPath);
+		if ($logicPath !== null) {
+			return $logicPath;
+		}
+
+		$this->insert($physicalPath, $physicalPath);
+		return $physicalPath;
+	}
+
+	/**
+	 * @param string $path
+	 * @param bool $isLogicPath indicates if $path is logical or physical
+	 * @param $recursive
+	 */
+	public function removePath($path, $isLogicPath, $recursive) {
+		if ($recursive) {
+			$path=$path.'%';
+		}
+
+		if ($isLogicPath) {
+			$query = \OC_DB::prepare('DELETE FROM `*PREFIX*file_map` WHERE `logic_path` LIKE ?');
+			$query->execute(array($path));
+		} else {
+			$query = \OC_DB::prepare('DELETE FROM `*PREFIX*file_map` WHERE `physic_path` LIKE ?');
+			$query->execute(array($path));
+		}
+	}
+
+	/**
+	 * @param $path1
+	 * @param $path2
+	 * @throws \Exception
+	 */
+	public function copy($path1, $path2)
+	{
+		$path1 = $this->stripLast($path1);
+		$path2 = $this->stripLast($path2);
+		$physicPath1 = $this->logicToPhysical($path1, true);
+		$physicPath2 = $this->logicToPhysical($path2, true);
+
+		$query = \OC_DB::prepare('SELECT * FROM `*PREFIX*file_map` WHERE `logic_path` LIKE ?');
+		$result = $query->execute(array($path1.'%'));
+		$updateQuery = \OC_DB::prepare('UPDATE `*PREFIX*file_map`'
+			.' SET `logic_path` = ?'
+			.' AND `physic_path` = ?'
+			.' WHERE `logic_path` = ?');
+		while( $row = $result->fetchRow()) {
+			$currentLogic = $row['logic_path'];
+			$currentPhysic = $row['physic_path'];
+			$newLogic = $path2.$this->stripRootFolder($currentLogic, $path1);
+			$newPhysic = $physicPath2.$this->stripRootFolder($currentPhysic, $physicPath1);
+			if ($path1 !== $currentLogic) {
+				try {
+					$updateQuery->execute(array($newLogic, $newPhysic, $currentLogic));
+				} catch (\Exception $e) {
+					error_log('Mapper::Copy failed '.$currentLogic.' -> '.$newLogic.'\n'.$e);
+					throw $e;
+				}
+			}
+		}
+	}
+
+	/**
+	 * @param $path
+	 * @param $root
+	 * @return bool|string
+	 */
+	public function stripRootFolder($path, $root) {
+		if (strpos($path, $root) !== 0) {
+			// throw exception ???
+			return false;
+		}
+		if (strlen($path) > strlen($root)) {
+			return substr($path, strlen($root));
+		}
+
+		return '';
+	}
+
+	private function stripLast($path) {
+		if (substr($path, -1) == '/') {
+			$path = substr_replace($path ,'',-1);
+		}
+		return $path;
+	}
+
+	private function resolveLogicPath($logicPath) {
+		$logicPath = $this->stripLast($logicPath);
+		$query = \OC_DB::prepare('SELECT * FROM `*PREFIX*file_map` WHERE `logic_path_hash` = ?');
+		$result = $query->execute(array(md5($logicPath)));
+		$result = $result->fetchRow();
+
+		return $result['physic_path'];
+	}
+
+	private function resolvePhysicalPath($physicalPath) {
+		$physicalPath = $this->stripLast($physicalPath);
+		$query = \OC_DB::prepare('SELECT * FROM `*PREFIX*file_map` WHERE `physic_path_hash` = ?');
+		$result = $query->execute(array(md5($physicalPath)));
+		$result = $result->fetchRow();
+
+		return $result['logic_path'];
+	}
+
+	private function create($logicPath, $store) {
+		$logicPath = $this->stripLast($logicPath);
+		$index = 0;
+
+		// create the slugified path
+		$physicalPath = $this->slugifyPath($logicPath);
+
+		// detect duplicates
+		while ($this->resolvePhysicalPath($physicalPath) !== null) {
+			$physicalPath = $this->slugifyPath($physicalPath, $index++);
+		}
+
+		// insert the new path mapping if requested
+		if ($store) {
+			$this->insert($logicPath, $physicalPath);
+		}
+
+		return $physicalPath;
+	}
+
+	private function insert($logicPath, $physicalPath) {
+		$query = \OC_DB::prepare('INSERT INTO `*PREFIX*file_map`(`logic_path`, `physic_path`, `logic_path_hash`, `physic_path_hash`) VALUES(?, ?, ?, ?)');
+		$query->execute(array($logicPath, $physicalPath, md5($logicPath), md5($physicalPath)));
+	}
+
+	private function slugifyPath($path, $index=null) {
+		$pathElements = explode('/', $path);
+		$sluggedElements = array();
+
+		// skip slugging the drive letter on windows - TODO: test if local path
+		if (strpos(strtolower(php_uname('s')), 'win') !== false) {
+			$sluggedElements[]= $pathElements[0];
+			array_shift($pathElements);
+		}
+		foreach ($pathElements as $pathElement) {
+			// TODO: remove file ext before slugify on last element
+			$sluggedElements[] = self::slugify($pathElement);
+		}
+
+		//
+		// TODO: add the index before the file extension
+		//
+		if ($index !== null) {
+			$last= end($sluggedElements);
+			array_pop($sluggedElements);
+			array_push($sluggedElements, $last.'-'.$index);
+		}
+		return implode(DIRECTORY_SEPARATOR, $sluggedElements);
+	}
+
+	/**
+	 * Modifies a string to remove all non ASCII characters and spaces.
+	 *
+	 * @param string $text
+	 * @return string
+	 */
+	private function slugify($text)
+	{
+		// replace non letter or digits by -
+		$text = preg_replace('~[^\\pL\d]+~u', '-', $text);
+
+		// trim
+		$text = trim($text, '-');
+
+		// transliterate
+		if (function_exists('iconv')) {
+			$text = iconv('utf-8', 'us-ascii//TRANSLIT', $text);
+		}
+
+		// lowercase
+		$text = strtolower($text);
+
+		// remove unwanted characters
+		$text = preg_replace('~[^-\w]+~', '', $text);
+
+		if (empty($text))
+		{
+			// TODO: we better generate a guid in this case
+			return 'n-a';
+		}
+
+		return $text;
+	}
+}
diff --git a/lib/files/storage/common.php b/lib/files/storage/common.php
index 591803f0440..ce9e7ead6d1 100644
--- a/lib/files/storage/common.php
+++ b/lib/files/storage/common.php
@@ -277,4 +277,27 @@ abstract class Common implements \OC\Files\Storage\Storage {
 			return uniqid();
 		}
 	}
+	
+	/**
+	 * clean a path, i.e. remove all redundant '.' and '..'
+	 * making sure that it can't point to higher than '/'
+	 * @param $path The path to clean
+	 * @return string cleaned path
+	 */
+	public function cleanPath($path) {
+		if (strlen($path) == 0 or $path[0] != '/') {
+			$path = '/' . $path;
+		}
+		
+		$output = array();
+		foreach (explode('/', $path) as $chunk) {
+			if ($chunk == '..') {
+				array_pop($output);
+			} else if ($chunk == '.') {
+			} else {
+				$output[] = $chunk;
+			}
+		}
+		return implode('/', $output);
+	}
 }
diff --git a/lib/files/storage/local.php b/lib/files/storage/local.php
index a5db4ba9194..9fe01135866 100644
--- a/lib/files/storage/local.php
+++ b/lib/files/storage/local.php
@@ -8,6 +8,10 @@
 
 namespace OC\Files\Storage;
 
+if (\OC_Util::runningOnWindows()) {
+	require_once 'mappedlocal.php';
+} else {
+
 /**
  * for local filestore, we only have to map the paths
  */
@@ -19,6 +23,8 @@ class Local extends \OC\Files\Storage\Common{
 			$this->datadir.='/';
 		}
 	}
+	public function __destruct() {
+	}
 	public function getId(){
 		return 'local::'.$this->datadir;
 	}
@@ -245,3 +251,4 @@ class Local extends \OC\Files\Storage\Common{
 		return $this->filemtime($path)>$time;
 	}
 }
+}
diff --git a/lib/files/storage/mappedlocal.php b/lib/files/storage/mappedlocal.php
new file mode 100644
index 00000000000..80dd79bc41f
--- /dev/null
+++ b/lib/files/storage/mappedlocal.php
@@ -0,0 +1,335 @@
+<?php
+/**
+ * Copyright (c) 2012 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+namespace OC\Files\Storage;
+
+/**
+ * for local filestore, we only have to map the paths
+ */
+class Local extends \OC\Files\Storage\Common{
+	protected $datadir;
+	private $mapper;
+
+	public function __construct($arguments) {
+		$this->datadir=$arguments['datadir'];
+		if(substr($this->datadir, -1)!=='/') {
+			$this->datadir.='/';
+		}
+
+		$this->mapper= new \OC\Files\Mapper();
+	}
+	public function __destruct() {
+		if (defined('PHPUNIT_RUN')) {
+			$this->mapper->removePath($this->datadir, true, true);
+		}
+	}
+	public function getId(){
+		return 'local::'.$this->datadir;
+	}
+	public function mkdir($path) {
+		return @mkdir($this->buildPath($path));
+	}
+	public function rmdir($path) {
+		if ($result = @rmdir($this->buildPath($path))) {
+			$this->cleanMapper($path);
+		}
+		return $result;
+	}
+	public function opendir($path) {
+		$files = array('.', '..');
+		$physicalPath= $this->buildPath($path);
+
+		$logicalPath = $this->mapper->physicalToLogic($physicalPath);
+		$dh = opendir($physicalPath);
+		while ($file = readdir($dh)) {
+			if ($file === '.' or $file === '..') {
+				continue;
+			}
+
+			$logicalFilePath = $this->mapper->physicalToLogic($physicalPath.DIRECTORY_SEPARATOR.$file);
+
+			$file= $this->mapper->stripRootFolder($logicalFilePath, $logicalPath);
+			$file = $this->stripLeading($file);
+			$files[]= $file;
+		}
+
+		\OC\Files\Stream\Dir::register('local-win32'.$path, $files);
+		return opendir('fakedir://local-win32'.$path);
+	}
+	public function is_dir($path) {
+		if(substr($path,-1)=='/') {
+			$path=substr($path, 0, -1);
+		}
+		return is_dir($this->buildPath($path));
+	}
+	public function is_file($path) {
+		return is_file($this->buildPath($path));
+	}
+	public function stat($path) {
+		$fullPath = $this->buildPath($path);
+		$statResult = stat($fullPath);
+
+		if ($statResult['size'] < 0) {
+			$size = self::getFileSizeFromOS($fullPath);
+			$statResult['size'] = $size;
+			$statResult[7] = $size;
+		}
+		return $statResult;
+	}
+	public function filetype($path) {
+		$filetype=filetype($this->buildPath($path));
+		if($filetype=='link') {
+			$filetype=filetype(realpath($this->buildPath($path)));
+		}
+		return $filetype;
+	}
+	public function filesize($path) {
+		if($this->is_dir($path)) {
+			return 0;
+		}else{
+			$fullPath = $this->buildPath($path);
+			$fileSize = filesize($fullPath);
+			if ($fileSize < 0) {
+				return self::getFileSizeFromOS($fullPath);
+			}
+
+			return $fileSize;
+		}
+	}
+	public function isReadable($path) {
+		return is_readable($this->buildPath($path));
+	}
+	public function isUpdatable($path) {
+		return is_writable($this->buildPath($path));
+	}
+	public function file_exists($path) {
+		return file_exists($this->buildPath($path));
+	}
+	public function filemtime($path) {
+		return filemtime($this->buildPath($path));
+	}
+	public function touch($path, $mtime=null) {
+		// sets the modification time of the file to the given value.
+		// If mtime is nil the current time is set.
+		// note that the access time of the file always changes to the current time.
+		if(!is_null($mtime)) {
+			$result=touch( $this->buildPath($path), $mtime );
+		}else{
+			$result=touch( $this->buildPath($path));
+		}
+		if( $result ) {
+			clearstatcache( true, $this->buildPath($path) );
+		}
+
+		return $result;
+	}
+	public function file_get_contents($path) {
+		return file_get_contents($this->buildPath($path));
+	}
+	public function file_put_contents($path, $data) {//trigger_error("$path = ".var_export($path, 1));
+		return file_put_contents($this->buildPath($path), $data);
+	}
+	public function unlink($path) {
+		return $this->delTree($path);
+	}
+	public function rename($path1, $path2) {
+		if (!$this->isUpdatable($path1)) {
+			\OC_Log::write('core','unable to rename, file is not writable : '.$path1,\OC_Log::ERROR);
+			return false;
+		}
+		if(! $this->file_exists($path1)) {
+			\OC_Log::write('core','unable to rename, file does not exists : '.$path1,\OC_Log::ERROR);
+			return false;
+		}
+
+		$physicPath1 = $this->buildPath($path1);
+		$physicPath2 = $this->buildPath($path2);
+		if($return=rename($physicPath1, $physicPath2)) {
+			// mapper needs to create copies or all children
+			$this->copyMapping($path1, $path2);
+			$this->cleanMapper($physicPath1, false, true);
+		}
+		return $return;
+	}
+	public function copy($path1, $path2) {
+		if($this->is_dir($path2)) {
+			if(!$this->file_exists($path2)) {
+				$this->mkdir($path2);
+			}
+			$source=substr($path1, strrpos($path1, '/')+1);
+			$path2.=$source;
+		}
+		if($return=copy($this->buildPath($path1), $this->buildPath($path2))) {
+			// mapper needs to create copies or all children
+			$this->copyMapping($path1, $path2);
+		}
+		return $return;
+	}
+	public function fopen($path, $mode) {
+		if($return=fopen($this->buildPath($path), $mode)) {
+			switch($mode) {
+				case 'r':
+					break;
+				case 'r+':
+				case 'w+':
+				case 'x+':
+				case 'a+':
+					break;
+				case 'w':
+				case 'x':
+				case 'a':
+					break;
+			}
+		}
+		return $return;
+	}
+
+	public function getMimeType($path) {
+		if($this->isReadable($path)) {
+			return \OC_Helper::getMimeType($this->buildPath($path));
+		}else{
+			return false;
+		}
+	}
+
+	private function delTree($dir, $isLogicPath=true) {
+		$dirRelative=$dir;
+		if ($isLogicPath) {
+			$dir=$this->buildPath($dir);
+		}
+		if (!file_exists($dir)) {
+			return true;
+		}
+		if (!is_dir($dir) || is_link($dir)) {
+			if($return=unlink($dir)) {
+				$this->cleanMapper($dir, false);
+				return $return;
+			}
+		}
+		foreach (scandir($dir) as $item) {
+			if ($item == '.' || $item == '..') {
+				continue;
+			}
+			if(is_file($dir.'/'.$item)) {
+				if(unlink($dir.'/'.$item)) {
+					$this->cleanMapper($dir.'/'.$item, false);
+				}
+			}elseif(is_dir($dir.'/'.$item)) {
+				if (!$this->delTree($dir. "/" . $item, false)) {
+					return false;
+				};
+			}
+		}
+		if($return=rmdir($dir)) {
+			$this->cleanMapper($dir, false);
+		}
+		return $return;
+	}
+
+	private static function getFileSizeFromOS($fullPath) {
+		$name = strtolower(php_uname('s'));
+		// Windows OS: we use COM to access the filesystem
+		if (strpos($name, 'win') !== false) {
+			if (class_exists('COM')) {
+				$fsobj = new \COM("Scripting.FileSystemObject");
+				$f = $fsobj->GetFile($fullPath);
+				return $f->Size;
+			}
+		} else if (strpos($name, 'bsd') !== false) {
+			if (\OC_Helper::is_function_enabled('exec')) {
+				return (float)exec('stat -f %z ' . escapeshellarg($fullPath));
+			}
+		} else if (strpos($name, 'linux') !== false) {
+			if (\OC_Helper::is_function_enabled('exec')) {
+				return (float)exec('stat -c %s ' . escapeshellarg($fullPath));
+			}
+		} else {
+			\OC_Log::write('core', 'Unable to determine file size of "'.$fullPath.'". Unknown OS: '.$name, \OC_Log::ERROR);
+		}
+
+		return 0;
+	}
+
+	public function hash($path, $type, $raw=false) {
+		return hash_file($type, $this->buildPath($path), $raw);
+	}
+
+	public function free_space($path) {
+		return @disk_free_space($this->buildPath($path));
+	}
+
+	public function search($query) {
+		return $this->searchInDir($query);
+	}
+	public function getLocalFile($path) {
+		return $this->buildPath($path);
+	}
+	public function getLocalFolder($path) {
+		return $this->buildPath($path);
+	}
+
+	protected function searchInDir($query, $dir='', $isLogicPath=true) {
+		$files=array();
+		$physicalDir = $this->buildPath($dir);
+		foreach (scandir($physicalDir) as $item) {
+			if ($item == '.' || $item == '..')
+				continue;
+			$physicalItem = $this->mapper->physicalToLogic($physicalDir.DIRECTORY_SEPARATOR.$item);
+			$item = substr($physicalItem, strlen($physicalDir)+1);
+
+			if(strstr(strtolower($item), strtolower($query)) !== false) {
+				$files[]=$dir.'/'.$item;
+			}
+			if(is_dir($physicalItem)) {
+				$files=array_merge($files, $this->searchInDir($query, $physicalItem, false));
+			}
+		}
+		return $files;
+	}
+
+	/**
+	 * check if a file or folder has been updated since $time
+	 * @param string $path
+	 * @param int $time
+	 * @return bool
+	 */
+	public function hasUpdated($path, $time) {
+		return $this->filemtime($path)>$time;
+	}
+
+	private function buildPath($path, $create=true) {
+		$path = $this->stripLeading($path);
+		$fullPath = $this->datadir.$path;
+		return $this->mapper->logicToPhysical($fullPath, $create);
+	}
+
+	private function cleanMapper($path, $isLogicPath=true, $recursive=true) {
+		$fullPath = $path;
+		if ($isLogicPath) {
+			$fullPath = $this->datadir.$path;
+		}
+		$this->mapper->removePath($fullPath, $isLogicPath, $recursive);
+	}
+
+	private function copyMapping($path1, $path2) {
+		$path1 = $this->stripLeading($path1);
+		$path2 = $this->stripLeading($path2);
+
+		$fullPath1 = $this->datadir.$path1;
+		$fullPath2 = $this->datadir.$path2;
+
+		$this->mapper->copy($fullPath1, $fullPath2);
+	}
+
+	private function stripLeading($path) {
+		if(strpos($path, '/') === 0) {
+			$path = substr($path, 1);
+		}
+
+		return $path;
+	}
+}
diff --git a/lib/files/storage/temporary.php b/lib/files/storage/temporary.php
index 542d2cd9f48..d84dbda2e39 100644
--- a/lib/files/storage/temporary.php
+++ b/lib/files/storage/temporary.php
@@ -21,6 +21,7 @@ class Temporary extends Local{
 	}
 
 	public function __destruct() {
+		parent::__destruct();
 		$this->cleanUp();
 	}
 }
diff --git a/lib/files/view.php b/lib/files/view.php
index dfcb770328b..1a234228eab 100644
--- a/lib/files/view.php
+++ b/lib/files/view.php
@@ -509,11 +509,7 @@ class View {
 		if (Filesystem::isValidPath($path)) {
 			$source = $this->fopen($path, 'r');
 			if ($source) {
-				$extension = '';
-				$extOffset = strpos($path, '.');
-				if ($extOffset !== false) {
-					$extension = substr($path, strrpos($path, '.'));
-				}
+				$extension = pathinfo($path, PATHINFO_EXTENSION);
 				$tmpFile = \OC_Helper::tmpFile($extension);
 				file_put_contents($tmpFile, $source);
 				return $tmpFile;