PageRenderTime 45ms CodeModel.GetById 12ms RepoModel.GetById 0ms app.codeStats 0ms

/apuxin/services/vfs/vfs.php

http://apuxin.googlecode.com/
PHP | 1607 lines | 693 code | 140 blank | 774 comment | 128 complexity | 5738a654dd866c7dc9e1dc7e5a5ec7b8 MD5 | raw file
Possible License(s): GPL-3.0, LGPL-2.1
  1. <?php
  2. /**
  3. ==============================
  4. VV VV FFFFFF SSSSSS
  5. VV VV FF SS
  6. VV VV FFFFF SSSSSS
  7. VVVV FF SS
  8. VV FF SSSSSS
  9. ===============================
  10. Virtual File System
  11. Name: VFS - Virtual File System
  12. Version: 0.7 alpha 2
  13. Author: Markus Gutbrod
  14. Authormail: gutbrod.markus@googlemail.com
  15. Website: http://code.google.com/p/apuxin
  16. */
  17. function ddefine($name, $value)
  18. {
  19. if(!defined($name)) {
  20. define($name, $value);
  21. return true;
  22. }
  23. return false;
  24. }
  25. // "Verzeichnis-Teiler", z.B. / oder \
  26. ddefine("DS", DIRECTORY_SEPARATOR);
  27. // Definiere VFS-Version
  28. ddefine("VirtualFileSystem", "0.7 alpha 2");
  29. // Wie hei?t die Einstellungsdatei?
  30. ddefine("VFS_SETTING", "settings.vfs.php");
  31. // Wie hei?t das Einstellungsverzeichnis
  32. ddefine("VFS_SETTINGS", "settings".DS);
  33. // Wie hei?t das Dateiverzeichnis
  34. ddefine("VFS_FILES", "files".DS);
  35. // Wie hei?t des ?ffentliche Verzeichnis?
  36. ddefine("VFS_PUBLIC", "public".DS);
  37. // Wie hei?t das Verzeichnis des Papierkorbs?
  38. ddefine("VFS_TRASH", "trash".DS);
  39. // Datenverzeichnis
  40. ddefine("VFS_DATA", "data".DS);
  41. // PluginVerzeichnis
  42. ddefine("VFS_PLUGINS", "vfs".DS."plugins".DS);
  43. // Das Zeichen, das VFS zeigt, dass eine Datei oder ein Ordner versteckt ist
  44. ddefine("HIDDENSIGN", "_");
  45. ddefine("BR", "\r\n");
  46. // Funktion zum einfachen einbinden von Dateien laden
  47. include_once( "vfs".DS."importer.php");
  48. // Der Zugriff von VFS (VirtualFileSystem) auf RFS(RealFileSystem)
  49. jimport("vfs.rfs");
  50. // Mathematische Funktionen
  51. jimport("math");
  52. // Optionen
  53. jimport("options");
  54. // EventHandler
  55. jimport("events");
  56. // Umrechnung von Dateigr??en
  57. jimport("vfs.filesize");
  58. // Errormeldungen
  59. jimport("vfs.errno");
  60. // Errorlogger
  61. jimport("vfs.errorlog");
  62. // Eigentliche Klasse
  63. class VirtualFileSystem extends EventHandler
  64. {
  65. // Speichert den Pfad zum Dateisystem
  66. private $path;
  67. // Speichert den Pfad zum Verzeichnis eines Users
  68. private $upath;
  69. // Speicherung des Benutzernamens
  70. private $uname;
  71. // Boolean: eingeloggt (true) oder nicht eingeloggt (false)
  72. private $logged_in;
  73. // Das Dateiverzeichnis des eingeloggten Users
  74. private $fs;
  75. // Handler f?r Dateien
  76. private $files;
  77. // Soll VFS ohne Plugins geladen werden?
  78. private $safemod;
  79. // Verzeichnisstruktur (FolderStructure)
  80. private $folderStructure;
  81. // Soll Passwort ben?tigt werden?
  82. private $requirePassword;
  83. /**
  84. * Konstruktor
  85. * Initialisierung aller Variablen
  86. *
  87. * Argumente:
  88. * $path - Pfad zum Dateisystem
  89. */
  90. function __construct( $path, $requirePassword = false, $safemod = false)
  91. {
  92. // Speichere den Pfad zum Dateisystem
  93. $this->path = dirname(__FILE__).DS.$path.DS;
  94. // Leere alle Variablen, beziehungsweise initialisiere sie
  95. $this->_clear();
  96. // soll safemod aktiviert werden?
  97. $this->safemod = $safemod;
  98. $this->requirePassword = $requirePassword;
  99. $this->files = array();
  100. $this->folderStructure = array();
  101. parent::__construct();
  102. }
  103. /**
  104. * Desktruktor
  105. * Sorgt daf?r, dass beim beenden alle Dateien geschlossen werden.
  106. */
  107. function __destruct()
  108. {
  109. foreach($this->files as $key=>$v) {
  110. $this->close($key);
  111. }
  112. }
  113. /**
  114. * add2FolderStructure
  115. * F?gt Nutzerverzeichnisse hinzu, die vorhanden sein m?ssen
  116. */
  117. public function add2FolderStructure($stringOfFolder)
  118. {
  119. $this->folderStructure[] = $stringOfFolder;
  120. $this->fireEvent("add2FolderStructure", $stringOfFolder);
  121. }
  122. /**
  123. * error
  124. * Speicherung von auftretenden Fehlern, beziehungsweise deren ?bergabe an das Objekt der Klasse "Errorlogger"
  125. *
  126. * Argumente:
  127. * $errno - Fehlernummer, siehe dazu die Datei vfs/errno.php
  128. * $detailed - eventuell weitere Informationen zum aufgetretenen Fehler
  129. */
  130. private function error( $errno, $detailed )
  131. {
  132. $this->fireEvent("error", array($errno, $detailed));
  133. }
  134. /**
  135. * _clear
  136. * Initialisieren/Leeren von (System-)Variablen
  137. */
  138. private function _clear()
  139. {
  140. // Pfad zum Benutzerverzeichnis
  141. $this->upath = "";
  142. // Benutzername
  143. $this->uname = "";
  144. // ist jemand eingeloggt?
  145. $this->logged_in = false;
  146. // Verzeichnisbaum
  147. $this->fs = false;
  148. }
  149. /**
  150. * loggedIn
  151. * Gibt zur?ck, ob schon ein Nutzer eingeloggt wurde
  152. *
  153. * R?ckgabewerte:
  154. * true - es ist bereits ein User eingeloggt
  155. * false - es ist noch kein Nutzer eingeloggt
  156. */
  157. public function loggedIn()
  158. {
  159. if(!$this->logged_in) {
  160. return false;
  161. }
  162. return true;
  163. }
  164. /**
  165. * login
  166. * Loggt einen Nutzer ein
  167. *
  168. * Argumente:
  169. * $username - Username eines Nutzers und ...
  170. * $passwd - ... das passende Passwort dazu
  171. *
  172. * R?ckgabewerte:
  173. * true - Der User wurde erfolgreich eingeloggt
  174. * false - Fehler beim Einloggen
  175. *
  176. * Errormeldungen:
  177. * 2019 - Es ist bereits ein User eingeloggt
  178. */
  179. public function login( $username, $passwd = "" )
  180. {
  181. // Pr?fe, ob schon jemand eingeloggt ist
  182. if($this->loggedIn()) {
  183. $this->error(2019, "");
  184. return false;
  185. }
  186. // Bearbeite den Usernamen; Speicherung erfolgt immer nur in Kleinbuchstaben
  187. $username = strtolower($username);
  188. // Pfad zum User-Verzeichnis zusammenbauen
  189. $path = $this->path.$username.DS;
  190. // Pr?fung, ob der User existiert
  191. if(!folder_exists($path)) {
  192. return false;
  193. }
  194. // Binde Usereinstellungen ein
  195. include_once($path.VFS_SETTING);
  196. // Pr?fe, ob das Passwort ben?tigt wird und richtig ist
  197. if((!empty($passwd) || $this->requirePassword) && $this->passwd($passwd) != $vfs_user_settings[$username]['passwd']) {
  198. return false;
  199. }
  200. // Speichere Userpfad
  201. $this->upath = $path;
  202. // Speichere Einstellungen
  203. $this->uname = $vfs_user_settings[$username]['username'];
  204. // Setze LoggedIn-Flag
  205. $this->logged_in = true;
  206. // F?r eine erh?hte Sicherheit werden die Einstellungen gel?scht, so dass sie nur in dieser Klasse weiter verwendet werden k?nnen
  207. unset($vfs_user_settings);
  208. $this->fireEvent("login", $this->uname);
  209. return true;
  210. }
  211. /**
  212. * Logout
  213. * Leerung aller Variablen -> kommt einem Logout gleich
  214. */
  215. public function logout()
  216. {
  217. $this->_clear();
  218. $this->fireEvent("logout");
  219. }
  220. /**
  221. * passwd
  222. * Verschl?sselt ein Passwort
  223. *
  224. * Argumente:
  225. * $passwd - Das Passwort, das Verschl?sselt werden soll
  226. *
  227. * R?ckgabewerte:
  228. * (md5) - Verschl?sseltes Passwort
  229. */
  230. private function passwd( $passwd )
  231. {
  232. return md5($passwd);
  233. }
  234. /**
  235. * userexist
  236. * Pr?ft, ob ein User existiert
  237. *
  238. * Argumente:
  239. * $username - Benutzername, der gepr?ft werden soll
  240. *
  241. * R?ckgabewerte:
  242. * true - User existiert
  243. * false - User existiert nicht
  244. */
  245. public function userexist( $username )
  246. {
  247. if(folder_exists($this->path.strtolower($username).DS)) {
  248. return true;
  249. }
  250. return false;
  251. }
  252. /**
  253. * useradd
  254. * Erstellt einen neuen Nutzer
  255. *
  256. * Argumente:
  257. * $username - Username und ...
  258. * $password - Passwort des zu erstellenden Users
  259. *
  260. * R?ckgabewerte:
  261. * true - Usereinrichtung erfolgreich
  262. * false - Fehler beim Einrichten des Users
  263. *
  264. * Errormeldungen:
  265. * 2021 - Verzeichnis f?r diesen User bereits vorhanden
  266. */
  267. public function useradd( $username, $password/*, $xml = array() */)
  268. {
  269. if(empty($username) || empty($password)) {
  270. return false;
  271. }
  272. // VFS nutzt nur klein-geschriebene Verzeichnisse
  273. $un = strtolower($username);
  274. if(folder_exists($this->path.$un.DS)) {
  275. $this->error(2021, $un);
  276. return false;
  277. }
  278. // Verschl?ssele Passwort
  279. $passwd = $this->passwd($password);
  280. $upath = $this->path.$un.DS;
  281. // Erstelle Verzeichnisstruktur
  282. mkdir($upath, 0777);
  283. // Arbeite Verzeichnisliste ab
  284. foreach($this->folderStructure as $fstruc) {
  285. mkdir($upath.$fstruc, 0777);
  286. }
  287. // Schreibe Einstellungsdatei
  288. $fp = fopen($upath.DS.VFS_SETTING, "w");
  289. if(!$fp) {
  290. // Fehler zur?ckgeben, falls sie nicht erstellt werden konnte
  291. return false;
  292. }
  293. fputs($fp, "<?php\n");
  294. fputs($fp, "\$vfs_user_settings['".$un."'] = array();\n");
  295. // Nutzername
  296. fputs($fp, "\$vfs_user_settings['".$un."']['username'] = \"".$username."\";\n");
  297. // Passwort
  298. fputs($fp, "\$vfs_user_settings['".$un."']['passwd'] = \"".$passwd."\";\n");
  299. fputs($fp, "?>");
  300. fclose($fp);
  301. $this->fireEvent("useradd", $username);
  302. return true;
  303. }
  304. /**
  305. * userdel
  306. * l?scht einen User
  307. *
  308. * Argumente:
  309. * $username - Name des Nutzers, der gel?scht werden soll
  310. *
  311. * R?ckgabewerte:
  312. * true - User erfolgreich gel?scht
  313. * false -
  314. *
  315. * Errormeldungen:
  316. * 2022 - Verzeichnis dieses User nicht vorhanden, vll wurde er schon gel?scht
  317. */
  318. public function userdel( $username )
  319. {
  320. $username = strtolower($username);
  321. // Pr?fe, ob User existiert
  322. if(!folder_exists($this->path.$username.DS)) {
  323. // Gebe Fehlermeldung zur?ck
  324. $this->error(2022, $username);
  325. return false;
  326. }
  327. // Ordner l?schen
  328. folder_remove($this->path.$username);
  329. $this->fireEvent("userdel", $username);
  330. return true;
  331. }
  332. /**
  333. * username
  334. * gibt den Usernamen des aktuell eingeloggten Benutzers zur?ck
  335. *
  336. * Argumente:
  337. * $path - Aktueller Pfad
  338. *
  339. * R?ckgabewerte:
  340. * (array) - Gesamter Verzeichnisinhalt (rekursiv)
  341. * false - User ist nicht eingeloggt, oder Verzeichnis existiert nicht
  342. */
  343. public function username( )
  344. {
  345. if(!$this->logged_in) {
  346. return false;
  347. }
  348. return $this->uname;
  349. }
  350. /**
  351. * _index
  352. * Hilfsfunktion, um alle Dateien zu indizieren
  353. *
  354. * Argumente:
  355. * $path - Aktueller Pfad
  356. *
  357. * R?ckgabewerte:
  358. * (array) - Gesamter Verzeichnisinhalt (rekursiv)
  359. * false - User ist nicht eingeloggt, oder Verzeichnis existiert nicht
  360. */
  361. private function _index( $path )
  362. {
  363. // Pr?fen, ob User eingeloggt ist
  364. if(!$this->logged_in) {
  365. return false;
  366. }
  367. // Wenn Verzeichnis nicht vorhanden, -> Fehlermeldung
  368. if(!folder_exists($path)) {
  369. return false;
  370. }
  371. // Variable f?r die Dateien/Ordner
  372. $arr = array();
  373. // Arbeite alle Ordner nacheinander ab
  374. foreach(createDirectoryList($path, true, "dir") as $dir) {
  375. // F?ge Ordner zur Dateiliste hinzu
  376. $arr[] = array(
  377. $dir, // Ordnername
  378. "dir", // Indikator f?r Ordner
  379. 0, // Gr??e des Ordners
  380. $path.$dir.DS, // Der Pfad zum Ordner
  381. "vfs", // Handler (wie der Ordner gehandhabt werden soll)
  382. $this->_index($path.$dir.DS), // Dateien/Ordner in diesem Ordner
  383. );
  384. }
  385. // Arbeite alle Dateien nacheinander ab
  386. foreach(createDirectoryList($path /*Pfad*/, true /*auch versteckte*/, "file" /*Dateien*/) as $file) {
  387. $arr[] = array(
  388. $file, // Dateiname
  389. "file", // Indikator f?r Datei
  390. filesize($path.DS.$file), // Dateigr??e
  391. $path.$file, // Pfad zur Datei
  392. "vfs", // Handler (wie die Datei ge?ffnet werden soll)
  393. array() // Reserviert f?r Dateien innerhalb der Datei (z.B. Archive)
  394. );
  395. }
  396. // Datei-/Ordnerliste zur?ckgeben
  397. return $arr;
  398. }
  399. /**
  400. * index
  401. * Funktion, die ein Verzeichnis ausliest und eventuell existierende Plugins einbezieht
  402. *
  403. * R?ckgabewerte:
  404. * false - Fehler beim Auslesen; User ist nicht eingeloggt
  405. *
  406. * Errormeldungen:
  407. * 2012 - Benutzer ist nicht eingeloggt
  408. */
  409. public function index( ) {
  410. // Pr?fe, ob Benutzer eingeloggt ist
  411. if(!$this->logged_in) {
  412. $this->error(2012, "");
  413. return false;
  414. }
  415. // Schreibe Verzeichnisstruktur in die Objektvariable $fs (FileSystem)
  416. $this->fs = $this->_index($this->upath);
  417. // Nur wenn der Safemod nicht aktiviert ist, sollen Plugins eingebunden werden
  418. if(!$this->safemod) {
  419. // Arbeite alle Dateien im Verzeichnis §Plugins§/dirreader ab
  420. foreach(createDirectoryList(VFS_PLUGINS."dirreader", false, "file") as $f) {
  421. // Streiche die Endung weg
  422. $f = crossOutFileType($f);
  423. // Importiere die Funktion
  424. jimport(VFS_PLUGINS."dirreader".DS.$f);
  425. // Erst pr?fen, ob die Funktion existiert
  426. if(function_exists($f)) {
  427. // Rufe die Funktion auf
  428. $this->fs = call_user_func($listener, $path, $this->fs);
  429. }
  430. }
  431. }
  432. $this->fireEvent("index");
  433. }
  434. /**
  435. * isHidden
  436. * Pr?ft, ob eine Datei versteckt ist
  437. *
  438. * Argumente:
  439. * $filename - Dateiname, der zu ?berpr?fen ist
  440. *
  441. * R?ckgabewerte:
  442. * true - Datei soll versteckt werden
  443. * false - Datei soll nicht versteckt werden
  444. */
  445. private function isHidden( $filename )
  446. {
  447. if($filename[0] == HIDDENSIGN) {
  448. return true;
  449. }
  450. return false;
  451. }
  452. /**
  453. * browse
  454. * Gebe eine Datei-/Ordnerliste zu einem Verzeichnis aus
  455. *
  456. * Argumente:
  457. * $path - Pfad zum Ordner
  458. * $options - Optionen
  459. * showHiddenElements (Standard: false) - Sollen versteckte Elemente angezeigt werden?
  460. * showFiles (Standard: true) - Sollen Dateien angezeigt werden?
  461. * showFolders (Standard: true) - Sollen Ordner angezeigt werden?
  462. * urgeInFolder (Standard: VFS_FILES) - In welchen Ordner soll die Funktion eingesperrt werden?
  463. *
  464. * R?ckgabewerte:
  465. * (array) - Dateiliste
  466. * false - User nicht eingeloggt
  467. *
  468. * Errormeldungen:
  469. * 2013 - User nicht eingeloggt
  470. */
  471. public function browse( $path, $options = array() )
  472. {
  473. if(!$this->logged_in) {
  474. $this->error(2013, "");
  475. return false;
  476. }
  477. // Definiere Standardoptionen
  478. $standardOptions = array(
  479. 'showHiddenElements' => false,
  480. 'showFiles' => true,
  481. 'showFolders' => true,
  482. 'urgeInFolder' => VFS_FILES
  483. );
  484. // Kombiniere Standard- und aktuelle Optionen
  485. $options = setOptions($standardOptions, $options);
  486. //print_r($options);exit;
  487. $fs = $this->_browse( $path, 0, $options );
  488. //print_r($fs);exit;
  489. if(!$fs) { $this->error(2023, $path); return false; }
  490. $list = array();
  491. foreach($fs as $ft) {
  492. if(!$options['showHiddenElements'] && $this->isHidden($ft[0])) {
  493. continue;
  494. }
  495. if(!$options['showFiles'] && $ft[1] == "file") {continue;}
  496. if(!$options['showFolders'] && $ft[1] == "dir") {continue;}
  497. $list[] = $ft[0];
  498. }
  499. return $list;
  500. }
  501. public function browseFolders( $path, $options = array() )
  502. {
  503. $options = setOptions($options, array('showFiles' => false));
  504. return $this->browse($path, $options);
  505. }
  506. public function browseFiles( $path, $options = array() )
  507. {
  508. $options = setOptions($options, array('showFolders' => false));
  509. return $this->browse($path, $options);
  510. }
  511. /**
  512. * _browse
  513. * Hilfsfunktion f?r browse
  514. *
  515. * Argumente:
  516. * $path - Pfad zum auszulesenden Verzeichnis
  517. * $mode - Welcher Modus?
  518. * 0 - Array von Dateien in diesem Ordner
  519. * 1 - Gibt den Pfad zur?ck. Dabei wird auch falsche Gro?-/Kleinschreibung korrigiert
  520. * 2 - Gibt ein Array des ganzen Ordners zur?ck (inkl. Gr??e, Handler, Pfad, Unterdateien/-ordner, ...)
  521. * $options - Optionen
  522. * urgeInFolder (Standard: VFS_FILES) - Soll die Funktion in einen Ordner eigesperrt werden
  523. *
  524. * R?ckgabewerte:
  525. * (array) - Verzeichnisbaum
  526. * false - nicht eingeloggt, oder Verzeichnis existiert nicht
  527. */
  528. private function _browse( $path, $mode = 0, $options = array() )
  529. {
  530. // Definiere Standardoptionen
  531. $standardOptions = array(
  532. 'urgeInFolder' => VFS_FILES,
  533. 'abortOnError' => true
  534. );
  535. // Kombiniere Standard- und aktuelle Optionen
  536. $options = setOptions($standardOptions, $options);
  537. $options['urgeInFolder'] = $this->_preparePath($options['urgeInFolder']);
  538. // Pr?fe, ob User eingelogt ist
  539. if(!$this->logged_in) {
  540. return false;
  541. }
  542. // Falls noch nichts ausgelesen wurde, dann rufe die Indexierungsfunktion auf
  543. if(!$this->fs) {
  544. $this->index();
  545. }
  546. // Aus Gr?nden der Kompatibilit?t
  547. if($mode === true) {
  548. $mode = 1;
  549. }
  550. // Pfad vorbereiten: Doppelte Slashes entfernen, Root-Zeichen weg
  551. $path = $this->_preparePath($path);
  552. //print_r($path);exit;
  553. $fs = array();
  554. //echo "<h2>browse</h2>";
  555. // Dateisystem laden
  556. if($options['urgeInFolder'] == DS) {
  557. //echo "whole";
  558. $fs = $this->fs;
  559. } else {
  560. //echo "part";
  561. $fs = $this->_browse($options['urgeInFolder'], 0, array('urgeInFolder' => DS));
  562. }
  563. // Root zur?ckgeben?
  564. if($path == DS) {
  565. // Root-Pfad zur?ckgeben
  566. if($mode == 1) {
  567. return DS;
  568. }
  569. if($mode == 2) {
  570. return array("root", "dir", 0, $this->upath.$options['urgeInFolder'].DS, "vfs", $fs);
  571. }
  572. // Das gesamte Dateisystem zur?ckgeben
  573. return $fs;
  574. }
  575. //echo "<h2>browse</h2>";
  576. //echo $path;
  577. // Pfad zerteilen, um jedes Verzeichnis einzeln abzuarbeiten
  578. $p = explode(DS, $path);
  579. // ?nderungen, die vorgenommen werden, in $changes speichern, um .. (Verzeichnis aufw?rts) auswerten zu k?nnen
  580. $changes = array($fs);
  581. // Pfad-Array, entspricht $p, nur neu zusammengesetzt
  582. $paths = array();
  583. //$lastNumber = 0;
  584. // Arbeite einzelne Ordner ab
  585. foreach($p as $q) {
  586. // Werte . (akutelles Verzeichnis aus: einfach fortfahren)
  587. if($q == ".") {
  588. continue;
  589. }
  590. // Wenn .. (Verzeichnis aufw?rts)
  591. if($q == "..") {
  592. // Letztes Verzeichnis wiederherstellen
  593. $t = count($changes)-2;
  594. if($t < 0) {$t = 0;} else {array_pop($changes);}
  595. $fs = $changes[$t];
  596. // Letztes Verzeichnis aus dem Verzeichnis-Array entfernen
  597. array_pop($paths);
  598. // Schleife neu starten-
  599. continue;
  600. }
  601. // Variable, um zu ?berpr?fen, ob ein Verzeichnis gefunden wurde
  602. $changed = false;
  603. // Suche Ordner im aktuellen Verzeichnis
  604. foreach($fs as $n=>$ft) {
  605. // Wenn das der gesuchte Ordner ist, dann:
  606. if(strtolower($ft[0]) == strtolower($q) && $ft[1] == "dir") {
  607. // Variable $fs neu beschreiben (mit dem Inhalt des aktuellen Verzeichnisses)
  608. $fs = $ft[5];
  609. // Speichere das aktuelle Verzeichnis in $changes, um .. (Verzeichnis aufw?rts) zu erm?glichen
  610. $changes[] = $fs;
  611. // Ordner gefunden -> in $paths hinzuf?gen
  612. $paths[] = $q;
  613. // Das Verzeichnis wurde gefunden
  614. $changed = true;
  615. // Schleife abbrechen, da das Verzeichnis gefunden wurde
  616. break;
  617. }
  618. }
  619. if(!$changed && $options['abortOnError']) {
  620. //echo "Verzeichnis nicht gefunden";
  621. return false;
  622. }
  623. }
  624. if($mode == 1) {
  625. return implode(DS, $paths);
  626. } else if($mode == 2) {
  627. $t = count($changes)-2;
  628. return array("root", "dir", 0, $this->upath.$options['urgeInFolder'].DS, "vfs", $changes[0]);
  629. return $changes[$t];
  630. }
  631. //print_r($fs);
  632. return $fs;
  633. }
  634. /**
  635. * sizeOfFolder
  636. * Ermittelt die Gr??e eines Ordners
  637. *
  638. * Argumente:
  639. * $path - Der Ordner, dessen Gr??e ermittelt werden soll
  640. * $options - Optionen
  641. * countHiddenElements (Standard: false) - Sollen versteckte Elemente mitgez?hlt werden?
  642. * countFolders (Standard: true) - Sollen Ordner mitgez?hlt werden?
  643. * countFiles (Standard: true) - Sollen Dateien mitgez?hlt werden?
  644. * urgeInFolder (Standard: VFS_FILES) - Soll die Abfrage in ein bestimmtes Verzeichnis gezw?ngt werden?
  645. *
  646. * R?ckgabewerte:
  647. * (int) - Gr??e des Ordners
  648. * false - User ist nicht eingeloggt
  649. *
  650. * Errormeldungen:
  651. * 2014 - User ist nicht eingeloggt
  652. * 2024 - Verzeichnis existiert nicht
  653. */
  654. public function sizeOfFolder( $path, $options = array() )
  655. {
  656. // Erst pr?fen, ob irgendjemand eingeloggt ist
  657. if(!$this->logged_in) {
  658. $this->error(2014, "");
  659. return false;
  660. }
  661. $standardOptions = array(
  662. 'countHiddenElements' => false,
  663. 'countFolders' => true,
  664. 'countFiles' => true,
  665. 'urgeInFolder' => VFS_FILES
  666. );
  667. $options = setOptions($standardOptions, $options);
  668. // Verzeichnisinhalt in die Variable $fs schreiben
  669. $fs = $this->_browse( $path, 0, array('urgeInFolder' => $options['urgeInFolder']) );
  670. // Wenn dabei ein Fehler aufgetreten ist, dann Fehlermeldung zur?ckgeben
  671. if(!$fs) { $this->error(2024, $path); return false; }
  672. // Dateigr??e: 0 Byte
  673. $size = 0;
  674. // Alle Dateien und Ordner in dem Verzeichnis abarbeiten
  675. foreach($fs as $ft) {
  676. // Wenn versteckte Ordner/Dateien nicht angezeigt werden sollen, dann einfach mit der Schleife weitermachen
  677. if(!$options['countHiddenElements'] && $this->isHidden($ft[0])) {continue;}
  678. // Wenn dies ein Verzeichnis ist, dann ...
  679. if($ft[1] == "dir" && $options['countFolders']) {
  680. // ... ruft sich diese Funktion mit dem neuen Ordner selbst auf
  681. $size += $this->sizeofFolder($path.DS.$ft[0]);
  682. // ansonsten ist es eine Datei und ...
  683. } else if($ft[1] == "file" && $options['countFiles']) {
  684. // die Dateigr??e wird dazugez?hlt
  685. $size += $ft[2];
  686. }
  687. }
  688. // Gr??e zur?ckgeben
  689. return $size;
  690. }
  691. /**
  692. * sizeOfFile
  693. * Ermittelt die Gr??e einer Datei
  694. *
  695. * Argumente:
  696. * $path - Die Datei, deren Gr??e ermittelt werden soll
  697. * $options - Optionen
  698. * urgeInFolder (Standard: VFS_FILES) - Soll die Abfrage in ein bestimmtes Verzeichnis gezw?ngt werden?
  699. *
  700. * R?ckgabewerte:
  701. * (int) - Gr??e der Datei
  702. * false - User ist nicht eingeloggt
  703. * - Datei existiert nicht
  704. *
  705. * Errormeldungen:
  706. * 2014 - User ist nicht eingeloggt
  707. * 2024 - Datei existiert nicht
  708. */
  709. public function sizeOfFile( $path, $options = array() )
  710. {
  711. // Erst pr?fen, ob irgendjemand eingeloggt ist
  712. if(!$this->logged_in) {
  713. $this->error(2014, "");
  714. return false;
  715. }
  716. // Optionsverarbeitung
  717. $standardOptions = array(
  718. 'urgeInFolder' => VFS_FILES
  719. );
  720. $options = setOptions($standardOptions, $options);
  721. // Verzeichnisinhalt in die Variable $fs schreiben
  722. $fs = $this->_searchFor(dirname($path), basename($path), $options);
  723. // Wenn dabei ein Fehler aufgetreten ist, dann Fehlermeldung zur?ckgeben
  724. if(!$fs) { $this->error(2024, $path); return false; }
  725. // Gr??e zur?ckgeben
  726. return $fs[2];
  727. }
  728. /**
  729. * _preparePath
  730. * Bereitet einen Pfad auf die weitere Verarbeitung vor
  731. *
  732. * Argumente:
  733. * $path - Der Pfad, der Verarbeitet werden soll
  734. *
  735. * R?ckgabewerte:
  736. * (string) - Der (optimierte) Pfad
  737. */
  738. private function _preparePath( $path )
  739. {
  740. //die($path);
  741. $path = str_replace(array("\\", "/"), array(DS, DS), $path);
  742. //echo "<h1>preparePath</h1>";
  743. if(empty($path)) {return DS;}
  744. // Root-Slash entfernen
  745. while($path[0] == DS) {
  746. $path = substr($path, 1, strlen($path));
  747. }
  748. while($path[strlen($path)-1] == DS) {
  749. $path = substr($path, 0, strlen($path)-1);
  750. }
  751. // Wenn der Pfad leer ist, dann gebe Root-Slash zur?ck
  752. if(empty($path) || $path == ".") {
  753. return DS;
  754. }
  755. // Ansonsten gebe den bearbeiteten Pfad zur?ck
  756. return $path;
  757. }
  758. /**
  759. * _searchFor
  760. * Sucht in einem Verzeichnis nach einer bestimmten Datei
  761. *
  762. * Argumente:
  763. * $path - Das Verzeichnis, in dem gesucht werden soll
  764. * $filename - Die Datei, die gesucht werden soll
  765. * $options - Optionen
  766. * urgeInFolder (Standard: VFS_FILES) - Soll die Abfrage in ein bestimmtes Verzeichnis gezw?ngt werden?
  767. *
  768. * R?ckgabewerte:
  769. * (array) - Informationen ?ber die Datei
  770. * false - ein Fehler ist aufgetreten
  771. */
  772. /*private function _searchFor( $path, $filename = "", $options = array() )
  773. {
  774. //echo "<h1>searchfor</h1>$path<br>$filename<br>";
  775. if(empty($path) && empty($filename)) {
  776. return false;
  777. } else if(empty($path)) {
  778. $path = DS;
  779. }
  780. $path = $this->getPath($path);
  781. if(!$path) {return false;}
  782. if(empty($filename) && $path == DS) {
  783. return false;
  784. } else if(empty($filename)) {
  785. $filename = basename($path);
  786. $path = dirname($path);
  787. }
  788. $fs = $this->_browse($path, 0, $options);
  789. if(!$fs) {return false;}
  790. //print_r($fs);
  791. foreach($fs as $ft) {
  792. if(strtolower($filename) == strtolower($ft[0])) {
  793. return $ft;
  794. }
  795. }
  796. return false;
  797. }*/
  798. private function _searchFor( $path, $filename, $options = array() )
  799. {
  800. $path = $this->_preparePath($path);
  801. if(empty($filename)) {return false;}
  802. $fs = $this->_browse($path, 0, $options);
  803. if(!$fs) {return false;}
  804. foreach($fs as $ft) {
  805. if(strtolower($filename) == strtolower($ft[0])) {
  806. return $ft;
  807. }
  808. }
  809. return false;
  810. }
  811. public function getPath( $path, $options = array() )
  812. {
  813. return $this->_browse($path, 1, $options);
  814. }
  815. public function exists( $path, $options = array() )
  816. {
  817. if($this->file_exists($path, $options) || $this->folder_exists($path, $options)) {
  818. return true;
  819. }
  820. return false;
  821. }
  822. public function file_exists( $path, $options = array() )
  823. {
  824. $fs = $this->_searchFor(dirname($path), basename($path), $options);
  825. if(!$fs) {
  826. return false;
  827. }
  828. if($fs[1] == "file") {
  829. return true;
  830. }
  831. return false;
  832. }
  833. /*public function folder_exists( $path )
  834. {
  835. $fs=$this->_searchFor(dirname($path), basename($path));
  836. if(!$fs) {
  837. return false;
  838. }
  839. if($fs[1] == "dir") {
  840. return true;
  841. }
  842. return false;
  843. }*/
  844. public function folder_exists( $path, $options = array() )
  845. {
  846. //echo "path:".$path.";";
  847. $pat = explode(DS, $path = $this->_preparePath($path));
  848. $fs = $this->_searchFor($path.DS."..", $pat[count($pat)-1], $options);
  849. if(!$fs) {return false;}
  850. if($fs[1]=="dir") {return true;}
  851. return false;
  852. }
  853. public function is_file( $path )
  854. {
  855. return $this->file_exists($path);
  856. }
  857. public function is_dir( $path )
  858. {
  859. return $this->folder_exists($path);
  860. }
  861. /*
  862. // Einstellungen rausgek?rzt, da es daf?r einen eigenen Service geben wird
  863. public function set( $group, $name, $value )
  864. {
  865. $group = strtolower($group);
  866. $name = strtolower($group);
  867. $this->handler['settings'][md5($group)]['file'] = $group;
  868. $this->handler['settings'][md5($group)]['values'][$name] = $value;
  869. $this->handler['settings'][md5($group)]['changed'] = true;
  870. }
  871. private function _get( $group, $name )
  872. {
  873. rewind($this->handler['settings'][$group]['pointer']);
  874. while($line = fgetcsv($this->handler['settings'][$group]['pointer'], 10000, ";", "\"")) {
  875. $n = strtolower($line[0]);
  876. $v = $line[1];
  877. if(isset($this->handler['settings'][$group]['values'][$n])) {
  878. continue;
  879. }
  880. $this->handler['settings'][$group]['values'][$n] = $v;
  881. }
  882. $this->handler['settings'][$group]['read'] = true;
  883. }
  884. public function get( $group, $name )
  885. {
  886. $group = strtolower($group);
  887. $mdg = md5($group);
  888. $name = strtolower($name);
  889. if(isset($this->handler['settings'][$mdg]['values'][$name])) {
  890. return $this->handler['settings'][$mdg]['values'][$name];
  891. }
  892. if(!isset($this->handler['settings'][md5($group)]['pointer'])) {
  893. $this->handler['settings'][md5($group)]['pointer'] = fopen($this->upath.VFS_SETTINGS.$group, "w+");
  894. }
  895. $this->_get( $mdg, $name );
  896. if(isset($this->handler['settings'][md5($group)]['values'][$name])) {
  897. return $this->handler['settings'][md5($group)]['values'][$name];
  898. }
  899. return false;
  900. }
  901. */
  902. /** private function _getHandler( $res )
  903. {
  904. /*echo "<h1>_getHandler</h1>";
  905. print_r($this->files);
  906. echo "<br>".$res;
  907. if(!isset($this->files[$res])) {
  908. return false;
  909. }
  910. return $this->files[$res]['handler'];
  911. }
  912. private function _getPointer( $res )
  913. {
  914. if(!isset($this->files[$res])) {
  915. return false;
  916. }
  917. return $this->files[$res]['pointer'];
  918. }*/
  919. /**
  920. * _callPluginFuncByRes
  921. * Hilfsfunktion zum Aufruf einer Handler-Funktion
  922. *
  923. * Argumente:
  924. * $res - Resource zur Datei
  925. * $type - Typ, der ausgef?hrt werden soll (create, open, write, read, close, ...)
  926. * $extension - Argumente, die der aufzurufenden Funktion ?bergeben werden sollen
  927. *
  928. * R?ckgabewerte:
  929. * (array) - Ergebnis des Funktionsaufrufs
  930. * false - ein Fehler ist aufgetreten
  931. */
  932. /** private function _callPluginFuncByRes( $res, $type, $extension = "" )
  933. {
  934. // Hole den Handler der Resource und wenn ...
  935. if(!$handler = $this->_getHandler($res)) {
  936. // ... die Resource nicht verf?gbar ist, bzw. wenn ein Fehler aufgetreten ist,
  937. // gebe Fehlermeldung aus
  938. return false;
  939. }
  940. // Hole den "Pointer", der auf die Datei zeigt
  941. $pointer = $this->_getPointer( $res );
  942. //debug: echo $pointer;
  943. // Baue den Funktionsnamen zusammen
  944. $func = "vfs_plugin_".$handler."_".$type;
  945. // Wenn die Funktion mit dem oben zusammengebauten Namen nicht existiert, ...
  946. if(!function_exists($func)) {
  947. // ... versuche die Datei mit dem enthaltenden Handler einzubinden
  948. $p = VFS_PLUGINS."fs_".$handler.".php";
  949. // Falls diese jedoch nicht existiert: Fehler
  950. if(!file_exists($p)) {return false;}
  951. // Einbinden der Handlerdatei
  952. jimport($p, true);
  953. // Wenn es die Funktion immer noch nicht gibt: Fehler
  954. if(!function_exists($func)) {/*echo "fehler:".$func."<br>";return false;}
  955. }
  956. // Rufe die Funktion auf und speichere das Ergebnis (Standardergebnis ist die Aktualiesierung des Pointers)
  957. $return = call_user_func($func, $this->files[$res]['pointer'], $extension);
  958. // Standard-R?ckgabewert: true
  959. $r = true;
  960. // Wenn der von der Funktion zur?ckgegebene Wert ein Array ist, dann gibt es neben dem Pointer noch ein
  961. // "richtiges Ergebnis"
  962. if(is_array($return)) {
  963. // Das "richtige" Ergebnis
  964. $r = $return['return'];
  965. // Der Pointer
  966. $return = $return['pointer'];
  967. }
  968. // Aktualisiere den Pointer in VFS
  969. $this->files[$res]['pointer'] = $return;
  970. // Gebe das "richtige" Ergebnis, bzw. den Standardwert "true" zur?ck
  971. return $r;
  972. }
  973. */
  974. public function getHandler($res)
  975. {
  976. if(!isset($this->files[$res])) {
  977. return false;
  978. }
  979. return $this->files[$res]['handler'];
  980. }
  981. private function _callFSFunc( $res, $subFunc, $options = array() )
  982. {
  983. if(!$handler = $this->getHandler($res)) {return false;}
  984. $funcName = 'vfs_plugin_'.$handler."_".$subFunc;
  985. //echo $funcName;
  986. if(!function_exists($funcName)) {
  987. //echo VFS_PLUGINS."fs_".$handler.".php";
  988. /*if(!file_exists(VFS_PLUGINS."fs_".$handler.".php")) {
  989. //echo "!ex";
  990. return false;
  991. }*/
  992. jimport(VFS_PLUGINS."fs_".$handler.".php", true);
  993. if(!function_exists($funcName)) {
  994. return false;
  995. }
  996. }
  997. $return = call_user_func($funcName, $this->files[$res]['pointer'], $options);
  998. $this->files[$res]['pointer'] = $return;
  999. if(isset($return['pointer'])) {
  1000. $this->files[$res]['pointer'] = $return['pointer'];
  1001. }
  1002. if(isset($return['return'])) {
  1003. $return = $return['return'];
  1004. } else {
  1005. $return = true;
  1006. }
  1007. return $return;
  1008. }
  1009. public function create( $pathToFile, $options = array() )
  1010. {
  1011. // Optionsbearbeitung
  1012. $standardOptions = array(
  1013. 'urgeInFolder' => VFS_FILES
  1014. );
  1015. $options = setOptions($standardOptions, $options);
  1016. // Wenn Datei existiert: Fehlermeldung
  1017. if($this->file_exists($pathToFile, $options)) { return false; }
  1018. $fs = $this->_browse(dirname($pathToFile), 2, $options);
  1019. if(!$fs) {return false;}
  1020. $handler = $fs[4];
  1021. $pathToFile = $fs[3].$pathToFile;
  1022. $res = md5(low($pathToFile));
  1023. $this->files[$res] = array('pointer' => $pathToFile, 'file' => $pathToFile, 'handler' => $handler);
  1024. $this->_callFSFunc($res, 'create');
  1025. $this->fireEvent("create", array($pathToFile, $options));
  1026. return $res;
  1027. }
  1028. /**
  1029. public function create($file, $vfssettings = false )
  1030. {
  1031. $dirname = dirname($file);
  1032. $filename = basename($file);
  1033. $res = md5(strtolower($file));
  1034. if(isset($this->files[$res])) {
  1035. return false;
  1036. }
  1037. if(!$vfssettings && $this->file_exists($file)) {
  1038. return false;
  1039. } else if (!$vfssettings) {
  1040. $fs = $this->_browse($dirname.DS."..", 2);
  1041. }
  1042. return $res;
  1043. }
  1044. */
  1045. public function mkdir ( $createFolder, $options = array() )
  1046. {
  1047. /** wird schon von $this->_browse ?bernommen
  1048. // Optionsbearbeitung
  1049. $standardOptions = array(
  1050. 'urgeInFolder' => VFS_FILES
  1051. );
  1052. $options = setOptions($standardOptions, $options); */
  1053. /** $options2 = $options;
  1054. $options2['abortOnError'] = false;*/
  1055. $dir = $this->_preparePath($createFolder);
  1056. $dir = explode(DS, $dir);
  1057. $dn = array_pop($dir);
  1058. $dir = implode(DS, $dir);
  1059. //echo "dir:".$dir."<br/>dn:".$dn."<br/>";
  1060. if(empty($dn)) {return false;}
  1061. if($this->folder_exists($createFolder, $options)) {return false;}
  1062. $fs = $this->_browse($dir, 2, $options);
  1063. if(!$fs) {return false;}
  1064. $handler = $fs[4];
  1065. $pathToFile = $fs[3].$createFolder;
  1066. $res = md5($pathToFile);
  1067. $this->files[$res] = array('pointer' => $pathToFile, 'file' => $pathToFile, 'handler' => $handler);
  1068. $this->fireEvent("mkdir", array($createFolder, $options));
  1069. return $this->_callFSFunc($res, 'mkdir');
  1070. }
  1071. public function open( $pathToFile, $options = array() )
  1072. {
  1073. // Optionsbearbeitung
  1074. $standardOptions = array(
  1075. 'urgeInFolder' => VFS_FILES,
  1076. 'createFile' => false
  1077. );
  1078. $options = setOptions($standardOptions, $options);
  1079. //print_r($options);
  1080. // Wenn Datei existiert: Fehlermeldung
  1081. if(!$this->file_exists($pathToFile, $options)) {
  1082. if($options['createFile']) {
  1083. return $this->create($pathToFile, $options);
  1084. }
  1085. //echo "!ex";
  1086. return false;
  1087. }
  1088. $fs = $this->_searchFor(dirname($pathToFile), basename($pathToFile), $options);
  1089. if(!$fs) {return false;}
  1090. $handler = $fs[4];
  1091. $pathToFile = $fs[3];
  1092. $res = md5(low($pathToFile));
  1093. $this->files[$res] = array('pointer' => $pathToFile, 'file' => $pathToFile, 'handler' => $handler);
  1094. $this->_callFSFunc($res, 'open');
  1095. $this->fireEvent("open", array($pathToFile, $options));
  1096. return $res;
  1097. }
  1098. /* public function open( $file, $vfssettings = false )
  1099. {
  1100. $dirname = dirname($file);
  1101. $filename = basename($file);
  1102. $res = md5(strtolower($file));
  1103. if(isset($this->files[$res])) {
  1104. return false;
  1105. }
  1106. if($file[0] != "/") {
  1107. $file = "/".$file;
  1108. }
  1109. if(!$vfssettings && $this->file_exists($file)) {
  1110. $fs = $this->_searchFor(dirname($file), basename($file));
  1111. //print_r($fs);
  1112. $handler = $fs[4];
  1113. //echo $handler;
  1114. $f = $fs[3];
  1115. $this->files[$res] = array('file'=>$file, 'handler'=>$handler, 'pointer'=>$f);
  1116. //echo "bis hierher l?ufts";
  1117. if(!$this->_callPluginFuncByRes($res, "open")) {
  1118. //echo "fehler beim Funktionsaufruf von _callPluginFuncByRes(".$res.")";
  1119. unset($this->files[$res]);
  1120. return false;
  1121. }
  1122. } else if(!$vfssettings) {
  1123. return false;
  1124. }
  1125. if($vfssettings && file_exists($this->upath.VFS_SETTINGS.$file)) {
  1126. jimport(VFS_PLUGINS."open/vfs.opener.php");
  1127. $f = explode(":", $file);
  1128. $f = $this->upath.VFS_SETTINGS.$f[1];
  1129. $this->files[$res] = array('file'=>$f, 'handler'=>"vfs", 'pointer'=>$f);
  1130. $this->_callPluginFuncByRes($res, "open");
  1131. } else if($vfssettings) {
  1132. return false;
  1133. }
  1134. //print_r($this->files);
  1135. return $res;
  1136. } */
  1137. /*
  1138. public function read( $res )
  1139. {
  1140. if(!$this->_getHandler($res)) {
  1141. return false;
  1142. }
  1143. return $this->_callPluginFuncByRes($res, "read");
  1144. }*/
  1145. public function get( $file, $options = array() )
  1146. {
  1147. return $this->getContents( $file, $options );
  1148. }
  1149. public function getContents( $file, $options = array() )
  1150. {
  1151. // Definiere Standardoptionen
  1152. $standardOptions = array(
  1153. 'glue' => ""
  1154. );
  1155. // Kombiniere Standard- und aktuelle Optionen
  1156. $options = setOptions($standardOptions, $options);
  1157. if(!$res = $this->open($file, $options)) {
  1158. return false;
  1159. }
  1160. $output = $this->readAll($res, 0, $options['glue']);
  1161. $this->close($res);
  1162. return $output;
  1163. }
  1164. public function put( $file, $string, $options = array() )
  1165. {
  1166. return $this->putContents($file, $string, $options);
  1167. }
  1168. public function putContents( $file, $string, $options = array() )
  1169. {
  1170. if(!$res = $this->open($file, $options)) {
  1171. return false;
  1172. }
  1173. $this->write($res, $string);
  1174. $this->close($res);
  1175. return true;
  1176. }
  1177. public function append( $file, $output, $options = array() )
  1178. {
  1179. if(!$res = $this->open($file, $options)) {return false;}
  1180. $this->seek($res);
  1181. $this->nl($res);
  1182. $this->write($res, $output);
  1183. $this->close($res);
  1184. }
  1185. public function seek( $res )
  1186. {
  1187. return $this->_callFSFunc($res, "seek");
  1188. }
  1189. public function nl( $res )
  1190. {
  1191. return $this->_callFSFunc($res, "nl");
  1192. }
  1193. public function write( $res, $string )
  1194. {
  1195. return $this->_callFSFunc($res, "write", $string);
  1196. }
  1197. public function overwrite( $res, $string )
  1198. {
  1199. if(!$this->getHandler($res)) {return false;}
  1200. $this->rewind($res);
  1201. $this->truncate($res);
  1202. $this->write($res, $string);
  1203. }
  1204. public function read( $res, $length = 0 )
  1205. {
  1206. return $this->_callFSFunc($res, "read", $length);
  1207. }
  1208. public function readAll( $res, $length = 0, $glue = "\n" )
  1209. {
  1210. $lines = array();
  1211. while($lines[] = $this->read($res, $length)) {
  1212. }
  1213. //if(count($lines)==0) {return false;}
  1214. if(empty($glue)) {return $lines;}
  1215. return implode($glue, $lines);
  1216. }
  1217. public function rewind( $res )
  1218. {
  1219. return $this->_callFSFunc($res, "rewind");
  1220. }
  1221. public function truncate( $res )
  1222. {
  1223. return $this->_callFSFunc($res, "truncate");
  1224. }
  1225. public function remove( $pathToFile, $options = array() )
  1226. {
  1227. if($this->is_file($pathToFile)) {
  1228. return $this->rm($pathToFile, $options);
  1229. }
  1230. if($this->is_dir($pathToFile)) {
  1231. return $this->rmdir($pathToFile, $options);
  1232. }
  1233. return false;
  1234. }
  1235. public function rm( $pathToFile, $options = array() )
  1236. {
  1237. if(!$this->file_exists($pathToFile, $options)) {
  1238. return false;
  1239. }
  1240. $fs = $this->_searchFor(dirname($pathToFile), basename($pathToFile), $options);
  1241. if(!$fs) {return false;}
  1242. $handler = $fs[4];
  1243. $pathToFile = $fs[3];
  1244. $res = md5(low($pathToFile));
  1245. if(isset($this->files[$res])) {
  1246. return false;
  1247. }
  1248. $this->files[$res] = array('pointer' => $pathToFile, 'file' => $pathToFile, 'handler' => $handler);
  1249. return $this->_callFSFunc($res, "delete");
  1250. }
  1251. public function rmdir( $pathToFile, $options )
  1252. {
  1253. // Optionsbearbeitung
  1254. $standardOptions = array(
  1255. 'recursive' => true
  1256. );
  1257. $options = setOptions($standardOptions, $options);
  1258. if(!$this->folder_exists($pathToFile, $options)) {
  1259. return false;
  1260. }
  1261. $fs = $this->_searchFor(dirname($pathToFile), basename($pathToFile), $options);
  1262. if(!$fs) {return false;}
  1263. $handler = $fs[4];
  1264. $pathToFile = $fs[3];
  1265. $res = md5(low($pathToFile));
  1266. if(isset($this->files[$res])) {
  1267. return false;
  1268. }
  1269. $this->files[$res] = array('pointer' => $pathToFile, 'file' => $pathToFile, 'handler' => $handler);
  1270. return $this->_callFSFunc($res, "rmdir");
  1271. }
  1272. public function close( $res )
  1273. {
  1274. $ret = $this->_callFSFunc($res, "close");
  1275. if(isset($this->files[$res])) {unset($this->files[$res]);}
  1276. return $ret;
  1277. }
  1278. /*
  1279. public function write( $res, $string )
  1280. {
  1281. if(!$this->_getHandler($res)) {
  1282. return false;
  1283. }
  1284. $this->_callPluginFuncByRes($res, "write", $string);
  1285. return true;
  1286. }*/
  1287. /** public function rewind( $res )
  1288. {
  1289. if(!$this->_getHandler($res)) {
  1290. return false;
  1291. }
  1292. $this->_callPluginFuncByRes($res, "rewind");
  1293. return true;
  1294. }*/
  1295. /** public function close( $res )
  1296. {
  1297. if(!$this->_getHandler($res)) {
  1298. return false;
  1299. }
  1300. $this->_callPluginFuncByRes($res, "close");
  1301. unset($this->files[$res]);
  1302. return true;
  1303. }*/
  1304. /*private function _getFolderOrFileHandler( $object, $options = array() )
  1305. {
  1306. if($this->file_exists($object, $options)) {
  1307. $fs = $this->_searchFor(dirname($object), basename($object), $options);
  1308. if(!$fs) {return false;}
  1309. return $fs[4];
  1310. }
  1311. if($this->folder_exists($object, $options)) {
  1312. $fs = $this->_browse(dirname($object), 2, $options);
  1313. if(!$fs) {return false;}
  1314. return $fs[4];
  1315. }
  1316. return false;
  1317. }*/
  1318. private function _copy_file( $source, $target, $options = array() )
  1319. {
  1320. // Optionen ?berschreiben, damit eine Neue Datei angelegt wird
  1321. $options = setOptions($options, array('createFile' => true));
  1322. // Daten aus der Quelldatei auslesen
  1323. $contentOfSource = $this->getContents($source, $options);
  1324. // Neue Datei ins Dateisystem schreiben
  1325. return $this->putContents($target, $contentOfSource, $options);
  1326. }
  1327. private function _copy_dir( $source, $target, $options = array() )
  1328. {
  1329. foreach($this->browseFolders($source) as $dir) {
  1330. $this->mkdir($target.DS.$dir);
  1331. $this->copy($source.DS.$dir.DS, $target.DS.$dir.DS, $options);
  1332. }
  1333. foreach($this->browseFiles($source) as $file) {
  1334. /*echo "<br>";
  1335. echo "Quelle: ".$source.DS.$file."<br>";
  1336. echo "Ziel: ".$target.DS.$file."<br>";*/
  1337. $this->copy($source.DS.$file, $target.DS.$file, $options);
  1338. }
  1339. return true;
  1340. }
  1341. public function copy( $source, $target, $options = array() )
  1342. {
  1343. if(empty($source) || empty($target)) {
  1344. return false;
  1345. }
  1346. if($this->is_file($source, $options)) {
  1347. return $this->_copy_file($source, $target, $options);
  1348. }
  1349. if($this->is_dir($source, $options)) {
  1350. return $this->_copy_dir($source, $target, $options);
  1351. }
  1352. return false;
  1353. }
  1354. public function rename( $source, $target, $options = array() )
  1355. {
  1356. if($this->is_dir($source) && !$this->folder_exists($target)) {
  1357. if(!$this->mkdir($target)) {
  1358. return false;
  1359. }
  1360. }
  1361. if(!$this->copy($source, $target, $options)) {
  1362. return false;
  1363. }
  1364. return $this->remove($source, $options);
  1365. }
  1366. public function move( $source, $target, $options = array() )
  1367. {
  1368. return $this->rename($source, $target, $options);
  1369. }
  1370. }
  1371. /*
  1372. echo "<h1>VFS</h1>";
  1373. $vfs = new VirtualFileSystem("filesystem", false);
  1374. $vfs->add2FolderStructure(VFS_FILES);
  1375. $vfs->add2FolderStructure(VFS_PUBLIC);
  1376. $vfs->add2FolderStructure(VFS_TRASH);
  1377. $vfs->add2FolderStructure(VFS_SETTINGS);
  1378. $vfs->add2FolderStructure(VFS_DATA);*/
  1379. /*
  1380. // Pr?ft, ob der User existiert.
  1381. if($vfs->userexist("markus")) {
  1382. echo "User existiert.<br>";
  1383. } else {
  1384. echo "User existiert nicht.<br>";
  1385. }
  1386. */
  1387. /*$vfs->addEvent("login", "EventFunction_Login", array("vfs", "0.5 alpha 1"));
  1388. function EventFunction_Login($uname)
  1389. {
  1390. echo "Folgender Nutzer wurde erfolgreich eingeloggt: ".$uname."<br>";
  1391. echo "Dies geschah ?ber ".func_get_arg(1)."<br>";
  1392. echo "Version: ".func_get_arg(2)."<br>";
  1393. }*/
  1394. //$vfs->removeEvent("login", "EventFunction_Login");
  1395. //$vfs->removeEvents();
  1396. //$vfs->login("markus");
  1397. // Pr?ft, ob jemand eingeloggt ist.
  1398. /*if($vfs->loggedIn("markus")) {
  1399. echo "Eingeloggt: ".$vfs->username()."<br>";
  1400. } else {
  1401. echo "Nicht eingeloggt.<br>";
  1402. }*/
  1403. //$vfs->login("markus", "gutbrod");
  1404. //$vfs->index();
  1405. //$vfs->delete("hallo.txt");
  1406. //print_r($vfs->fs);
  1407. //print_r($vfs->browse(DS));
  1408. //echo $vfs->sizeOfFolder(DS, array('countHiddenElements' => false));
  1409. //echo $vfs->sizeOfFile("vfs.php")+$vfs->sizeOfFile("options.php");
  1410. /*if($vfs->file_exists("vfs.php")) {
  1411. echo "JA";
  1412. } else {
  1413. echo "NEEEEIIIN";
  1414. }*/
  1415. /*if($vfs->folder_exists("test")) {
  1416. echo "JA";
  1417. } else {
  1418. echo "NEEEEIIIN";
  1419. }*/
  1420. //echo $vfs->getContents("hallo.txt", array('glue'=>"<br>"));
  1421. //$res = $vfs->open("hallo.txt");
  1422. //$vfs->append("hallo.txt", "NOch eine Zeile. Wo kommt die denn her???");
  1423. //$vfs->seek($res);
  1424. //$vfs->nl($res);
  1425. //$vfs->write($res, "hallo, ich bin schon wieder eine Zeile");
  1426. //$vfs->truncate($res);
  1427. //$vfs->write($res, array("testet die Write-Funktion", "jetzt aber mit 2 Zeilen"));
  1428. //$vfs->close($res);
  1429. //echo $vfs->read($res);
  1430. /*echo $vfs->readAll($res, 0, "<br>");
  1431. echo $vfs->readAll($res, 0, "<br>");
  1432. $vfs->rewind($res);
  1433. echo $vfs->readAll($res, 0, "<br>");*/
  1434. //$vfs->mkdir("test");
  1435. //if($vfs->put("test.txt", "hallo", array('createFile'=>true))) {echo "ja";}
  1436. //$vfs->put("test.txt", "Ein ganz langer Text, der zeigt was da so abgeht");
  1437. //echo $vfs->get("test.txt");
  1438. //$vfs->append("test.txt", "Ein weiterer text");
  1439. ?>