PHP View::fopen方法代码示例

 public function stream_open($path, $mode, $options, &$opened_path)
 {
     $this->setup();
     $path = substr($path, strlen('oc://'));
     $this->path = $path;
     $this->fileSource = self::$rootView->fopen($path, $mode);
     if (is_resource($this->fileSource)) {
         $this->meta = stream_get_meta_data($this->fileSource);
     }
     return is_resource($this->fileSource);
 }

 /**
  * create the certificate bundle of all trusted certificated
  */
 protected function createCertificateBundle()
 {
     $path = $this->getPathToCertificates();
     $certs = $this->listCertificates();
     $fh_certs = $this->view->fopen($path . '/rootcerts.crt', 'w');
     foreach ($certs as $cert) {
         $file = $path . '/uploads/' . $cert->getName();
         $data = $this->view->file_get_contents($file);
         if (strpos($data, 'BEGIN CERTIFICATE')) {
             fwrite($fh_certs, $data);
             fwrite($fh_certs, "\r\n");
         }
     }
     fclose($fh_certs);
 }

 /**
  * create the certificate bundle of all trusted certificated
  */
 public function createCertificateBundle()
 {
     $path = $this->getPathToCertificates();
     $certs = $this->listCertificates();
     if (!$this->view->file_exists($path)) {
         $this->view->mkdir($path);
     }
     $fhCerts = $this->view->fopen($path . '/rootcerts.crt', 'w');
     // Write user certificates
     foreach ($certs as $cert) {
         $file = $path . '/uploads/' . $cert->getName();
         $data = $this->view->file_get_contents($file);
         if (strpos($data, 'BEGIN CERTIFICATE')) {
             fwrite($fhCerts, $data);
             fwrite($fhCerts, "\r\n");
         }
     }
     // Append the default certificates
     $defaultCertificates = file_get_contents(\OC::$SERVERROOT . '/resources/config/ca-bundle.crt');
     fwrite($fhCerts, $defaultCertificates);
     // Append the system certificate bundle
     $systemBundle = $this->getCertificateBundle(null);
     if ($this->view->file_exists($systemBundle)) {
         $systemCertificates = $this->view->file_get_contents($systemBundle);
         fwrite($fhCerts, $systemCertificates);
     }
     fclose($fhCerts);
 }

 /**
  * @param string $path
  * @param int $maxX
  * @param int $maxY
  * @param boolean $scalingup
  * @param \OC\Files\View $fileview
  * @return bool|\OC_Image
  */
 public function getThumbnail($path, $maxX, $maxY, $scalingup, $fileview)
 {
     $content = $fileview->fopen($path, 'r');
     $content = stream_get_contents($content);
     //don't create previews of empty text files
     if (trim($content) === '') {
         return false;
     }
     $lines = preg_split("/\r\n|\n|\r/", $content);
     $fontSize = 5;
     //5px
     $lineSize = ceil($fontSize * 1.25);
     $image = imagecreate($maxX, $maxY);
     imagecolorallocate($image, 255, 255, 255);
     $textColor = imagecolorallocate($image, 0, 0, 0);
     foreach ($lines as $index => $line) {
         $index = $index + 1;
         $x = (int) 1;
         $y = (int) ($index * $lineSize) - $fontSize;
         imagestring($image, 1, $x, $y, $line, $textColor);
         if ($index * $lineSize >= $maxY) {
             break;
         }
     }
     $image = new \OC_Image($image);
     return $image->valid() ? $image : false;
 }

 /**
  * Opens a file for reading
  * @throws \RuntimeException
  */
 private function getFileHandle()
 {
     $fileHandle = $this->view->fopen($this->path, "r");
     if ($fileHandle === false) {
         $this->logError('Can not open for reading.', $this->id, $this->path);
         throw new \RuntimeException();
     } else {
         $this->logDebug('Scan started');
         $this->fileHandle = $fileHandle;
     }
 }

 /**
  * Encrypt all files in a directory
  * @param string $dirPath the directory whose files will be encrypted
  * @return bool
  * @note Encryption is recursive
  */
 public function encryptAll($dirPath)
 {
     $result = true;
     $found = $this->findEncFiles($dirPath);
     // Disable proxy to prevent file being encrypted twice
     \OC_FileProxy::$enabled = false;
     $versionStatus = \OCP\App::isEnabled('files_versions');
     \OC_App::disable('files_versions');
     $encryptedFiles = array();
     // Encrypt unencrypted files
     foreach ($found['plain'] as $plainFile) {
         //get file info
         $fileInfo = \OC\Files\Filesystem::getFileInfo($plainFile['path']);
         //relative to data/<user>/file
         $relPath = $plainFile['path'];
         //relative to /data
         $rawPath = '/' . $this->userId . '/files/' . $plainFile['path'];
         // keep timestamp
         $timestamp = $fileInfo['mtime'];
         // Open plain file handle for binary reading
         $plainHandle = $this->view->fopen($rawPath, 'rb');
         // Open enc file handle for binary writing, with same filename as original plain file
         $encHandle = fopen('crypt://' . $rawPath . '.part', 'wb');
         if (is_resource($encHandle) && is_resource($plainHandle)) {
             // Move plain file to a temporary location
             $size = stream_copy_to_stream($plainHandle, $encHandle);
             fclose($encHandle);
             fclose($plainHandle);
             $fakeRoot = $this->view->getRoot();
             $this->view->chroot('/' . $this->userId . '/files');
             $this->view->rename($relPath . '.part', $relPath);
             // set timestamp
             $this->view->touch($relPath, $timestamp);
             $encSize = $this->view->filesize($relPath);
             $this->view->chroot($fakeRoot);
             // Add the file to the cache
             \OC\Files\Filesystem::putFileInfo($relPath, array('encrypted' => true, 'size' => $encSize, 'unencrypted_size' => $size, 'etag' => $fileInfo['etag']));
             $encryptedFiles[] = $relPath;
         } else {
             \OCP\Util::writeLog('files_encryption', 'initial encryption: could not encrypt ' . $rawPath, \OCP\Util::FATAL);
             $result = false;
         }
     }
     \OC_FileProxy::$enabled = true;
     if ($versionStatus) {
         \OC_App::enable('files_versions');
     }
     $result = $result && $this->encryptVersions($encryptedFiles);
     return $result;
 }

 /**
  * @param $path raw path relative to data/
  * @param $mode
  * @param $options
  * @param $opened_path
  * @return bool
  */
 public function stream_open($path, $mode, $options, &$opened_path)
 {
     // assume that the file already exist before we decide it finally in getKey()
     $this->newFile = false;
     if (!isset($this->rootView)) {
         $this->rootView = new \OC_FilesystemView('/');
     }
     $this->session = new \OCA\Encryption\Session($this->rootView);
     $this->privateKey = $this->session->getPrivateKey();
     // rawPath is relative to the data directory
     $this->rawPath = \OC\Files\Filesystem::normalizePath(str_replace('crypt://', '', $path));
     $this->userId = Helper::getUser($this->rawPath);
     $util = new Util($this->rootView, $this->userId);
     // get the key ID which we want to use, can be the users key or the
     // public share key
     $this->keyId = $util->getKeyId();
     // Strip identifier text from path, this gives us the path relative to data/<user>/files
     $this->relPath = Helper::stripUserFilesPath($this->rawPath);
     // if raw path doesn't point to a real file, check if it is a version or a file in the trash bin
     if ($this->relPath === false) {
         $this->relPath = Helper::getPathToRealFile($this->rawPath);
     }
     if ($this->relPath === false) {
         \OCP\Util::writeLog('Encryption library', 'failed to open file "' . $this->rawPath . '" expecting a path to "files", "files_versions" or "cache"', \OCP\Util::ERROR);
         return false;
     }
     // Disable fileproxies so we can get the file size and open the source file without recursive encryption
     $proxyStatus = \OC_FileProxy::$enabled;
     \OC_FileProxy::$enabled = false;
     if ($mode === 'w' or $mode === 'w+' or $mode === 'wb' or $mode === 'wb+') {
         // We're writing a new file so start write counter with 0 bytes
         $this->size = 0;
         $this->unencryptedSize = 0;
     } else {
         if ($this->privateKey === false) {
             // if private key is not valid redirect user to a error page
             \OCA\Encryption\Helper::redirectToErrorPage($this->session);
         }
         $this->size = $this->rootView->filesize($this->rawPath, $mode);
     }
     $this->handle = $this->rootView->fopen($this->rawPath, $mode);
     \OC_FileProxy::$enabled = $proxyStatus;
     if (!is_resource($this->handle)) {
         \OCP\Util::writeLog('Encryption library', 'failed to open file "' . $this->rawPath . '"', \OCP\Util::ERROR);
     } else {
         $this->meta = stream_get_meta_data($this->handle);
     }
     return is_resource($this->handle);
 }

 /**
  * write one-time encryption passwords to a csv file
  *
  * @param array $passwords
  */
 protected function writePasswordsToFile(array $passwords)
 {
     $fp = $this->rootView->fopen('oneTimeEncryptionPasswords.csv', 'w');
     foreach ($passwords as $pwd) {
         fputcsv($fp, $pwd);
     }
     fclose($fp);
     $this->output->writeln("\n");
     $this->output->writeln('A list of all newly created passwords was written to data/oneTimeEncryptionPasswords.csv');
     $this->output->writeln('');
     $this->output->writeln('Each of these users need to login to the web interface, go to the');
     $this->output->writeln('personal settings section "ownCloud basic encryption module" and');
     $this->output->writeln('update the private key password to match the login password again by');
     $this->output->writeln('entering the one-time password into the "old log-in password" field');
     $this->output->writeln('and their current login password');
 }

 private function readHeader()
 {
     if ($this->isLocalTmpFile) {
         $handle = fopen($this->localTmpFile, 'r');
     } else {
         $handle = $this->rootView->fopen($this->rawPath, 'r');
     }
     if (is_resource($handle)) {
         $data = fread($handle, Crypt::BLOCKSIZE);
         $header = Crypt::parseHeader($data);
         $this->cipher = Crypt::getCipher($header);
         // remeber that we found a header
         if (!empty($header)) {
             $this->containHeader = true;
         }
         fclose($handle);
     }
 }

 public function show()
 {
     if ($this->useOriginal) {
         $fp = @$this->view->fopen($this->path, 'rb');
         $mtime = $this->view->filemtime($this->path);
         $size = $this->view->filesize($this->path);
         $mime = $this->view->getMimetype($this->path);
     } else {
         $fp = @fopen($this->path, 'rb');
         $mtime = filemtime($this->path);
         $size = filesize($this->path);
         $mime = \OC_Helper::getMimetype($this->path);
     }
     if ($fp) {
         \OCP\Response::enableCaching();
         \OCP\Response::setLastModifiedHeader($mtime);
         header('Content-Length: ' . $size);
         header('Content-Type: ' . $mime);
         fpassthru($fp);
     } else {
         \OC_Response::setStatus(\OC_Response::STATUS_NOT_FOUND);
     }
 }

 /**
  * @param string $path
  * @param int $maxX
  * @param int $maxY
  * @param boolean $scalingup
  * @param \OC\Files\View $fileview
  * @return bool|\OC_Image
  */
 public function getThumbnail($path, $maxX, $maxY, $scalingup, $fileview)
 {
     $content = $fileview->fopen($path, 'r');
     $content = stream_get_contents($content);
     //don't create previews of empty text files
     if (trim($content) === '') {
         return false;
     }
     $lines = preg_split("/\r\n|\n|\r/", $content);
     $fontSize = 5;
     //5px
     $lineSize = ceil($fontSize * 1.25);
     $image = imagecreate($maxX, $maxY);
     imagecolorallocate($image, 255, 255, 255);
     $textColor = imagecolorallocate($image, 0, 0, 0);
     $fontFile = __DIR__;
     $fontFile .= '/../../../core';
     $fontFile .= '/fonts/OpenSans-Regular.ttf';
     $canUseTTF = function_exists('imagettftext');
     foreach ($lines as $index => $line) {
         $index = $index + 1;
         $x = (int) 1;
         $y = (int) ($index * $lineSize);
         if ($canUseTTF === true) {
             imagettftext($image, $fontSize, 0, $x, $y, $textColor, $fontFile, $line);
         } else {
             $y -= $fontSize;
             imagestring($image, 1, $x, $y, $line, $textColor);
         }
         if ($index * $lineSize >= $maxY) {
             break;
         }
     }
     $image = new \OC_Image($image);
     return $image->valid() ? $image : false;
 }

 /**
  * @param $path
  * @param $mode
  * @param $options
  * @param $opened_path
  * @return bool
  */
 public function stream_open($path, $mode, $options, &$opened_path)
 {
     if (!isset($this->rootView)) {
         $this->rootView = new \OC_FilesystemView('/');
     }
     $this->session = new \OCA\Encryption\Session($this->rootView);
     $this->privateKey = $this->session->getPrivateKey($this->userId);
     $util = new Util($this->rootView, \OCP\USER::getUser());
     $this->userId = $util->getUserId();
     // Strip identifier text from path, this gives us the path relative to data/<user>/files
     $this->relPath = \OC\Files\Filesystem::normalizePath(str_replace('crypt://', '', $path));
     // rawPath is relative to the data directory
     $this->rawPath = $util->getUserFilesDir() . $this->relPath;
     // Disable fileproxies so we can get the file size and open the source file without recursive encryption
     $proxyStatus = \OC_FileProxy::$enabled;
     \OC_FileProxy::$enabled = false;
     if ($mode === 'w' or $mode === 'w+' or $mode === 'wb' or $mode === 'wb+') {
         // We're writing a new file so start write counter with 0 bytes
         $this->size = 0;
         $this->unencryptedSize = 0;
     } else {
         if ($this->privateKey === false) {
             // if private key is not valid redirect user to a error page
             \OCA\Encryption\Helper::redirectToErrorPage();
         }
         $this->size = $this->rootView->filesize($this->rawPath, $mode);
     }
     $this->handle = $this->rootView->fopen($this->rawPath, $mode);
     \OC_FileProxy::$enabled = $proxyStatus;
     if (!is_resource($this->handle)) {
         \OCP\Util::writeLog('Encryption library', 'failed to open file "' . $this->rawPath . '"', \OCP\Util::ERROR);
     } else {
         $this->meta = stream_get_meta_data($this->handle);
     }
     return is_resource($this->handle);
 }

 public static function fopen($path, $mode)
 {
     return self::$defaultInstance->fopen($path, $mode);
 }

 /**
  * Gets information about trashed notes
  *
  * @NoAdminRequired
  * @NoCSRFRequired
  * @CORS
  *
  * @return string
  */
 public function getTrashedNotes()
 {
     $dir = $this->request->getParam("dir", "");
     $customFileExtensions = $this->request->getParam("extensions", array());
     if (!is_array($customFileExtensions)) {
         $customFileExtensions = array();
     }
     $noteFileExtensions = array_merge(array("md", "txt"), $customFileExtensions);
     // remove leading "/"
     if (substr($dir, 0, 1) === "/") {
         $dir = substr($dir, 1);
     }
     // remove trailing "/"
     if (substr($dir, -1) === "/") {
         $dir = substr($dir, 0, -1);
     }
     $sortAttribute = $this->request->getParam("sort", "mtime");
     $sortDirectionParam = $this->request->getParam("sortdirection", "");
     $sortDirection = $sortDirectionParam !== "" ? $sortDirectionParam === 'desc' : true;
     $filesInfo = array();
     // generate the file list
     try {
         $files = Helper::getTrashFiles("/", $this->user, $sortAttribute, $sortDirection);
         $filesInfo = Helper::formatFileInfos($files);
     } catch (Exception $e) {
     }
     // only return notes (with extension ".txt", ".md" and the custom extensions) in the $dir directory
     $resultFilesInfo = array();
     foreach ($filesInfo as $fileInfo) {
         $pathParts = pathinfo($fileInfo["name"]);
         // if $fileInfo["extraData"] is not set we will have to show the note files from all folders in QOwnNotes
         $isInDir = isset($fileInfo["extraData"]) ? strpos($fileInfo["extraData"], $dir . "/" . $fileInfo["name"]) === 0 : true;
         $isNoteFile = in_array($pathParts["extension"], $noteFileExtensions);
         if ($isInDir && $isNoteFile) {
             $timestamp = (int) ($fileInfo["mtime"] / 1000);
             $fileName = '/files_trashbin/files/' . $fileInfo["name"] . ".d{$timestamp}";
             $view = new \OC\Files\View('/' . $this->user);
             $data = "";
             // load the file data
             $handle = $view->fopen($fileName, 'rb');
             if ($handle) {
                 $chunkSize = 8192;
                 // 8 kB chunks
                 while (!feof($handle)) {
                     $data .= fread($handle, $chunkSize);
                 }
             }
             $resultFilesInfo[] = ["noteName" => $pathParts["filename"], "fileName" => $fileInfo["name"], "timestamp" => $timestamp, "dateString" => $fileInfo["date"], "data" => $data];
         }
     }
     $data = array();
     $data['directory'] = $dir;
     $data['notes'] = $resultFilesInfo;
     return $data;
 }