PageRenderTime 59ms CodeModel.GetById 29ms RepoModel.GetById 1ms app.codeStats 0ms

/apuxin/vfs.php

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