docs/html/smumd-core_8php_source.html

00001 <?php
00002 /*! This is the Core Function File - Simple Multi User Managed Directory - SMUMD
00003  *      by Sascha Heinatz * sascha.heinatz@alice.de
00004  *      Copyright 2011.
00005  *
00006  *      This file is part of Simple Multi User Managed Directory - SMUMD.
00007  *
00008  *      Simple Multi User Managed Directory - SMUMD
00009  *      is free software: you can redistribute it and/or modify
00010  *      it under the terms of the GNU Lesser General Public License as published by
00011  *      the Free Software Foundation, either version 3 of the License, or
00012  *      (at your option) any later version.
00013  *
00014  *      Simple Multi User Managed Directory - SMUMD
00015  *      is distributed in the hope that it will be useful,
00016  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
00017  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00018  *      GNU Lesser General Public License for more details.
00019  *
00020  *      You should have received a copy of the GNU Lesser General Public License
00021  *      along with Simple Multi User Managed Directory - SMUMD.
00022  *      If not, see <http://www.gnu.org/licenses/>.
00023  *      <hr>
00024  */
00025 /* FUNKTIONEN */
00026 /* ********** */
00027 /*! \brief vergleichsfunktion sortierung
00028  *      \param $a erster wert
00029  *      \param $b zweiter wert
00030  *      \return strcasecmp()
00031  */
00032  function dircmp($a,$b) {
00033         /*! globale variablen festlegen */
00034         global $thedir;
00035         /*! vergleichs variablen setzen */
00036         $ab="";
00037         $bb="";
00038         /*! typ erster wert auf 'd' prüfen */
00039         if ($thedir[$a]["rights"]["typ"] == "d" ) {
00040         /*! typ ist 'd' erster vergleichwert equivalent 10- setzen */
00041         $ab = "10-".$thedir[$a]["filename"];
00042         } else {
00043         /*! typ ist nicht 'd' erster vergleichwert equivalent 20- setzen */
00044         $ab = "20-".$thedir[$a]["filename"];
00045         }
00046         /*! typ zweiter wert auf 'd' prüfen */
00047         if ($thedir[$b]["rights"]["typ"] == "d" ) {
00048         /*! typ ist 'd' zweiter vergleichwert equivalent 10- setzen */
00049         $bb = "10-".$thedir[$b]["filename"];
00050         } else {
00051         /*! typ ist nicht 'd' zweiter vergleichwert equivalent 20- setzen */
00052         $bb = "20-".$thedir[$b]["filename"];
00053         }
00054         /*! typ zweiter wert auf 'y' prüfen */
00055         if ($thedir[$b]["rights"]["typ"] == "y" ) {
00056         /*! typ ist 'y' zweiter vergleichwert equivalent 05- setzen */
00057         $bb = "05-";
00058         }
00059         /*! typ zweiter wert auf 'z' prüfen */
00060         if ($thedir[$b]["rights"]["typ"] == "z" ) {
00061         /*! typ ist 'z' zweiter vergleichwert equivalent 01- setzen */
00062         $bb = "01-";
00063         }
00064         /*! typ erster wert auf 'y' prüfen */
00065         if ($thedir[$a]["rights"]["typ"] == "y" ) {
00066         /*! typ ist 'y' erster vergleichwert equivalent 05- setzen */
00067         $ab = "05-";
00068         }
00069         /*! typ erster wert auf 'z' prüfen */
00070         if ($thedir[$a]["rights"]["typ"] == "z" ) {
00071         /*! typ ist 'z' erster vergleichwert equivalent 01- setzen */
00072         $ab = "01-";
00073         }
00074         /*! rückgabe verleichs ergebnis grösser gleich kleiner case sensitiv */
00075         return strcasecmp($ab, $bb);
00076 }
00077 /*! \brief vergleichsfunktion sortierung
00078  *      \param $a erster wert
00079  *      \param $b zweiter wert
00080  */
00081  function pathcmp($a,$b) {
00082         /*! globale variablen festlegen */
00083         global $thedir;
00084         /*! ersten wert setzen */
00085         $ab = $thedir[$a]["filename"];
00086         /*! zweiter wert setzen */
00087         $bb = $thedir[$b]["filename"];
00088         /*! rückgabe verleichs ergebnis grösser gleich kleiner case sensitiv  */
00089         return strcasecmp($ab, $bb);
00090 }
00091 /*! \brief Direktory Ausgabe Tabelle
00092  *      \param $thedir das Directory Array
00093  *      \return $thedirhtml Direktory Tabelle in HTML
00094  */
00095 function dirHTML($thedir) {
00096         /*! globale variablen festlegen */
00097         global $used;
00098         /*! Direktory Tabelle aufbauen */
00099         $thedirhtml=<<<DIRHTML
00100         <table class="dateitabelle" cellpadding="0" cellspacing="0">
00101         <tr>
00102                 <th class="yellowbk dateiicon">Typ</th>
00103                 <th class="yellowbk dateiname">Name</th>
00104                 <th class="yellowbk dateisize">size</th>
00105                 <th class="yellowbk dateiprotect">protector</th>
00106                 <th class="yellowbk dateioptions" colspan=2>options</th>
00107                 <th class="yellowbk dateilastlog" colspan=3>Last Log</th>
00108                 <th class="yellowbk dateidelete" >del</th>
00109                 <th class="yellowbk dateipermissions" colspan=10>permission</th>
00110         </tr>
00111 DIRHTML;
00112         uksort($thedir ,"dircmp");
00113         /*! Für Jeden Eintrag von Direktroy Tabelle */
00114         foreach ($thedir as $aentry) {
00115                 /*! Tabellenzeile START */
00116                 $thedirhtml .="<tr>";
00117                 /*! kein hintergrund */
00118                 $colorbk ="";
00119                 /*! typ ist 'd' dann background setzen */
00120                 if ($aentry["rights"]["typ"] == "d" ) {$colorbk ="greybk ";}
00121                 /*! Icons finden */
00122                 if ($aentry["rights"]["typ"] == "d" or $aentry["rights"]["typ"] == "z" or $aentry["rights"]["typ"] == "y" ) {
00123                         /*! für d z y ordner icon */
00124                         $dateiicon=$used["images"]."folder.gif";
00125                 } else {
00126                                 /*! für datei mit option protected datei gruen*/
00127                                 if ($aentry["options"]["protect"] != "") { $dateiicon=$used["images"]."item_moz-free.gif"; }
00128                                 /*! für datei mit keiner option protected */
00129                                 if ($aentry["options"]["protect"] == "") { $dateiicon=$used["images"]."item_moz.gif"; }
00130                                 /*! für datei mit option unprotected */
00131                                 if ($aentry["options"]["unprotect"] !="" ) {$dateiicon=$used["images"]."item_moz-access.gif";}
00132                 }
00133                 /*! Icon Bild */
00134                 $thedirhtml .="<td class=\"".$colorbk."dateiicon\"><img src=\"".$dateiicon."\" alter=\"Datei Icon\"></td>";
00135                 /*! Datei Name */
00136                 $thedirhtml .="<td class=\"".$colorbk."dateiname\">".$aentry["name"]."</td>";
00137                 /*! Datei Grösse lesbar dezimal */
00138                 $thedirhtml .="<td class=\"".$colorbk."dateigroesse\">".format_size($aentry["size"])."</td>";
00139                 /*! Protektion Benutzername */
00140                 $thedirhtml .="<td class=\"".$colorbk."benutzer\" >".$aentry["protection"]["user"]."</td>";
00141                 /*! Optionen protektion */
00142                 $theprotect="";
00143                 /*! wenn option protect dann protect button speichern */
00144                 if ($aentry["options"]["protect"] != "") $theprotect =$aentry["options"]["protect"];
00145                 /*! wenn option unprotect dann unprotect button speichern */
00146                 if ($aentry["options"]["unprotect"] != "") $theprotect =$aentry["options"]["unprotect"];
00147                 /*! opion ausgeben */
00148                 $thedirhtml .="<td  class=\"".$colorbk."sperrung\">".$theprotect."</td>";
00149                 /*! Optionen Datei Updaten */
00150                 $thedirhtml .="<td  class=\"".$colorbk."dateiupdate\">".$aentry["options"]["upload"]."</td>";
00151                 /*! Datei Letzter Eintrag von LogDatei */
00152                 $thedirhtml .="<td class=\"".$colorbk."lastlogseit\">".$aentry["lastlog"]["entry"]."</td>";
00153                 $thedirhtml .="<td class=\"".$colorbk."lastloguser\" >".$aentry["lastlog"]["user"]."</td>";
00154                 $thedirhtml .="<td class=\"".$colorbk."lastlogaction\">".$aentry["lastlog"]["action"]."</td>";
00155                 /*! Optionen löschen */
00156                 $thedirhtml .="<td class=\"".$colorbk."optiondelete\">".$aentry["options"]["delete"]."</td>";
00157                 /*! Datei Rechte  Dateityp */
00158                 $thedirhtml .="<td class=\"".$colorbk."permission\">".$aentry["rights"]["typ"]."</td>";
00159                 /*! Datei Rechte  Besitzer Lesen */
00160                 $thedirhtml .="<td class=\"".$colorbk."permission\">".$aentry["rights"]["owner"]["r"]."</td>";
00161                 /*! Datei Rechte  Besitzer Schreiben*/
00162                 $thedirhtml .="<td class=\"".$colorbk."permission\">".$aentry["rights"]["owner"]["w"]."</td>";
00163                 /*! Datei Rechte  Besitzer Ausführen*/
00164                 $thedirhtml .="<td class=\"".$colorbk."permission\">".$aentry["rights"]["owner"]["x"]."</td>";
00165                 /*! Datei Rechte  Gruppe Lesen */
00166                 $thedirhtml .="<td class=\"".$colorbk."permission\">".$aentry["rights"]["group"]["r"]."</td>";
00167                 /*! Datei Rechte  Gruppe Schreiben */
00168                 $thedirhtml .="<td class=\"".$colorbk."permission\">".$aentry["rights"]["group"]["w"]."</td>";
00169                 /*! Datei Rechte  Gruppe Ausführen */
00170                 $thedirhtml .="<td class=\"".$colorbk."permission\">".$aentry["rights"]["group"]["x"]."</td>";
00171                 /*! Datei Rechte  Alle Lesen */
00172                 $thedirhtml .="<td class=\"".$colorbk."permission\">".$aentry["rights"]["other"]["r"]."</td>";
00173                 /*! Datei Rechte  Alle Schreiben */
00174                 $thedirhtml .="<td class=\"".$colorbk."permission\">".$aentry["rights"]["other"]["w"]."</td>";
00175                 /*! Datei Rechte  Alle Ausführen */
00176                 $thedirhtml .="<td class=\"".$colorbk."permission\">".$aentry["rights"]["other"]["x"]."</td>";
00177                 /*! Tabellenzeile ENDE */
00178                 $thedirhtml .="</tr>";
00179         }
00180         /*! Tabelle ENDE */
00181         $thedirhtml .="</table>";
00182         /*! Direktory HTML Zurückgeben */
00183         return $thedirhtml;
00184 }
00185 /*! \brief user Login Form
00186  *      \return $htmlloginform user Login HTML Formular
00187  */
00188 function userloginForm() {
00189         /*! globale variablen festlegen */
00190         global $used;
00191         /*! loginform erzeugen */
00192         $htmlloginform =<<<HTMLLOGIN
00193         <FORM ID="USERLOGIN" ACTION="?" METHOD="POST" CLASS="gastlogin">
00194         <fieldset>
00195         <legend>User Login</legend>
00196         <label for="LOGINNAME">Login :</label><INPUT ID="LOGINNAME" NAME="username" VALUE="" TYPE="TEXT" SIZE="20" /><br />
00197         <label for="LOGINPASS">Password :</label><INPUT ID="LOGINPASS" NAME="userpass" VALUE="" TYPE="PASSWORD" SIZE="16" />
00198         $used[sidfield]
00199         <INPUT ID="LOGIN" NAME="LOGIN" TYPE="SUBMIT" VALUE="LogMeIn" />
00200         </fieldset>
00201         </FORM>
00202 HTMLLOGIN;
00203         /*! rueckgabe loginform */
00204         return $htmlloginform;
00205 }
00206 /*!     \brief write to logfile
00207  *      \param $logdata Aktion Text
00208  *      \param $pathdata der Pfad
00209  */
00210 function logThis($logdata,$pathdata) {
00211         /*! globale variablen festlegen */
00212         global $used;
00213         /*! datei zum anhängen öffnen */
00214     if (!$fh = fopen($used["logfilepath"], 'a')) {
00215         /*! fehlgeschlagen also error schreiben */
00216          $out["errors"] .= "Cannot open logfile file to append stuff  <br>";
00217         /*! erfolg also schreiben */
00218     } else {
00219                 /*! log text string erzeugen    */
00220                 $logtext = "<date>".date("Y-m-d")."</date><time>".date("H:i:s")."</time><user>".$used["username"]."</user><text>".$logdata."</text><path>".$pathdata."</path>\n";
00221                 /*! prüfen log text string geschrieben werden konnte */
00222                 if (fwrite($fh, $logtext) === FALSE) {
00223                         /*! fehlgeschlagen also error schreiben */
00224                         $out["errors"] .= "Cannot write to db file to append stuff <br>";
00225                 }
00226                 /*! log datei schliessen */
00227                 fclose($fh);
00228         }
00229 }
00230 /*! \brief check username exist
00231  *
00232  */
00233 function userexists($uname) {
00234         /*! globale variablen festlegen */
00235         global $out;
00236         global $used;
00237         global $FS;
00238         global $debugging;
00239         /*! Datei zum lesen oeffnen */
00240         if (!$fh = fopen($used["userlogindb"], 'r')) {
00241                 /*! fehler beim oeffen zum lesen */
00242                  $out["errors"] .= "Cannot open userlogin db file to read stuff  <br>";
00243         } else {
00244                 /*! datei wird gelesen */
00245                 /*! setzt regexpression username tag suche */
00246                 $theusernametag = "$<username>".$uname."</username>$";
00247                 /*! solange datei nicht zu ende ist */
00248                 while (!feof($fh)){
00249                                 /*! lese zeile */
00250                            $line = fgets ($fh);
00251                            /*! fehler beim lesen von zeile */
00252                            if ($line===FALSE) {
00253                                 /*! wenn debugg dann lese fehler ausgeben */
00254                                 if ($debugging)  $out["errors"] .= " cant read line <br>";
00255                            } else {
00256                                 /* gelesene zeile auf username tag untersuchen */
00257                                  if (preg_match($theusernametag,$line)) {
00258                                         /*! username gefunden also datei schliessen */
00259                                  fclose($fh);
00260                                         /*! rueckgabe wahr weil username gefunden */
00261                                  return true;
00262                                  }
00263                            };
00264                 }
00265                 /*! datei schliessen */
00266                 fclose($fh);
00267         }
00268         /*! rueckgabe falsch weil usernametag nicht gefunden */
00269         return false;
00270 }
00271 /*!     \brief create a new user
00272  *      \param $uname Username für neuen Benutzer
00273  *      \param $ulogin Loginname für neuen Benutzer
00274  *      \param $upass Userpasswort für neuen Benutzer
00275  *      \param $upassproof Userpasswort prüfung
00276  */
00277 function createanewuser($uname,$ulogin,$upass,$upassproof) {
00278         /*! globale variablen festlegen */
00279         global $out;
00280         global $used;
00281         global $FS;
00282         global $debugging;
00283         /*! boolean fuer existierende usernamen */
00284         $alreadyuser = false;
00285         /*! benoetigte daten checken */
00286         if ($uname == "" OR $ulogin == "" OR $upass == ""  OR $upassproof == "" ) {
00287                 /*! fehler ausgabe für */
00288                 $out["errors"] .= "kein ";
00289                 /*! username fehlt */
00290                 if ($uname == "") $out["errors"] .= "Username ";
00291                 /*! loginname fehlt */
00292                 if ($ulogin == "") $out["errors"] .= "Loginname ";
00293                 /*! passwort fehlt */
00294                 if ($upass == "") $out["errors"] .= "Password ";
00295                 /*! pass verify fehlt */
00296                 if ($upassproof == "") $out["errors"] .= "verifikation  <br>";
00297         } else {
00298                 /*! alle daten vorhanden also checken ob user schon existiert */
00299                 $alreadyuser = userexists($uname);
00300                 /*! user exisitert nicht dann */
00301                 if (!$alreadyuser) {
00302                         /*! pruefen ob passwort sicherheits eingabe uebereinstimmt */
00303                         if ($upass == $upassproof) {
00304                                 /*! sicherheitsabfrage ok also login datei zum anhaengen oeffnen */
00305                                 if (!$fh = fopen($used["userlogindb"], 'a')) {
00306                                         /*! fehler beim oeffnen von datei ausgeben */
00307                                          $out["errors"] .= "Cannot open userlogin db file to append stuff  <br>";
00308                                 } else {
00309                                         /*! datei wurde geoeffnet */
00310                                         /*! usertage erzeugen */
00311                                         $theusernametag = "<username>".$uname."</username>";
00312                                         /*! loginname verschlüsseln */
00313                                         $usermd5ulogin = md5($ulogin);
00314                                         /*! logintag erzeugen */
00315                                         $theuserlogintag ="<userlogin>".$usermd5ulogin."</userlogin>";
00316                                         /*! passwort fuer user verschluesseln */
00317                                         $usermd5upass = md5($upass."isuser");
00318                                         /*! passworttag erzeugen */
00319                                         $theuserpasstag ="<userpass>".$usermd5upass."</userpass>";
00320                                         /*! textzeile fuer userlogin erzeugen */
00321                                         $taggedline = $theusernametag.$theuserlogintag.$theuserpasstag;
00322                                         /*! neuer user zeile mit zeilenvorschub */
00323                                         $addnewuserline = $taggedline."\n";
00324                                         /*! neuen user anhaengen */
00325                                         if (fwrite($fh, $addnewuserline) === FALSE) {
00326                                                 /*! error ausgabe File Write */
00327                                                 $out["errors"] .= "Cannot write to userlogin db file to append stuff <br>";
00328                                         } else {
00329                                                 /*! inhalt konnte geschrieben werden erfolg ausgeben */
00330                                                 $out["errors"] .= "Added a new User ".$uname."<br>";
00331                                                 /*! logdatei erfolg schreiben */
00332                                                 logThis("added new user",$uname);
00333                                         }
00334                                         /*! datei schliessen */
00335                                         fclose($fh);
00336                                         /*! rueckgabe user wurde geschrieben (wahr ) */
00337                                         return true;
00338                                 }
00339                         } else {
00340                                 /*! error ausgabe passwort stimmt nicht ueberein */
00341                                 $out["errors"] .= "passwords missmatch error <br>";
00342                         }
00343                 } else {
00344                         /*! error ausgabe user existiert schon */
00345                         $out["errors"] .= "Username exists already <br>";
00346                 }
00347         }
00348         /*! fehler beim hinzufuegen von neuem user */
00349         return false;
00350 }
00351
00352 /*! \brief neuen ordner anlegen
00353  *      \param $foldername Ordner Name
00354  */
00355 function createfolder($foldername) {
00356         /*! globale variablen festlegen */
00357         global $out;
00358         global $used;
00359         global $FS;
00360         global $debugging;
00361         /*! ordnername vorhanden */
00362         if ($foldername == "" ) {
00363                 /*! kein foldername dann error ausgeben */
00364                 $out["errors"] .= "geben sie einen Namen für den Ordner an";
00365         } else {
00366                 /*! gesamt pfad fuer ordner erzeugen */
00367                 $structure = $used['pathnow'].$foldername;
00368                 /*! ueberpruefen ob ordner existiert */
00369                 if (!file_exists($structure)) {
00370                         /*! ordner existiert nicht also verzeichnis erzeugen */
00371                         if (!mkdir($structure, 0755)) {
00372                                 /*! error ausgabe Fehler beim Verzeichnis erstellen */
00373                                 $out["errors"] .= "Erstellung des Verzeichnis '.$structure.' schlug fehl... ";
00374                         } else {
00375                                 /*! erfolg Ordner ausgabe fuer debug */
00376                                 if ($debugging) $out["errors"] .= "Ordner ".$foldername." wurde angelegt ";
00377                                 /*! erfolg Ordner erzeugt loggen */
00378                                 logThis("created folder",$structure);
00379                         }
00380                 } else {
00381                         /*! fehler beim Ordner erzeugen ausgeben */
00382                         $out["errors"] .= "Datei oder Verzeichnis mit gleichem namen vorhanden ";
00383                 }
00384         }
00385 }
00386 /*! \brief lösche ordner
00387  *      \param $foldername Ordner Name
00388  */
00389 function deletefolder($foldername) {
00390         /*! globale variablen festlegen */
00391         global $out;
00392         global $used;
00393         global $FS;
00394         global $debugging;
00395         /*! gesamt pfad fuer ordner erzeugen */
00396         $structure = $used['pathnow'].$foldername;
00397         /*! ueberpruefen ob datei existiert */
00398         if (file_exists($structure)) {
00399                 /*! ueberpruefen ob ordner*/
00400                 if (is_dir($structure)) {
00401                         /*! ist ordner also loeshen */
00402                         if (!rmdir($structure)) {
00403                                 /*! fuer debugger fehler beim loeschen ausgeben */
00404                                 if ($debugging) $out["errors"] .= "is dir - die Löschung des Verzeichnis '.$structure.' schlug fehl... ";
00405                                 /*! error ausgabe Ordner löschen */
00406                                 $out["errors"] .= "Ordner ".$foldername." konnte nicht gelöscht werden ";
00407                         } else {
00408                                 /*! fuer debugger  loesch erfolg ausgeben */
00409                                 if ($debugging) $out["errors"] .= "Ordner ".$foldername." wurde gelöscht ";
00410                                 /*! loesch erfolg loggen */
00411                                 logThis("deleted folder",$structure);
00412                         }
00413                 } else {
00414                         /*! error ausgabe Ordner löschen */
00415                         $out["errors"] .= "Ordner ".$foldername." konnte nicht gelöscht werden weil kein directory ";
00416                 }
00417         } else {
00418                         /*! error ausgabe verzeichnis nicht vorhanden */
00419                         $out["errors"] .= "Datei oder Verzeichnis existiert nicht ";
00420         }
00421 }
00422 /*! \brief lösche Datei
00423  *      \param $filename Datei Name
00424  */
00425 function deletefile($filename) {
00426         /*! globale variablen festlegen */
00427         global $out;
00428         global $used;
00429         global $FS;
00430         global $debugging;
00431         /*! gesamt pfad fuer ordner erzeugen */
00432         $structure = $used['pathnow'].$filename;
00433         /*! ueberpruefen ob datei existiert */
00434         if (file_exists($structure)) {
00435                 /*! ueberpruefen ob datei */
00436                 if (is_file($structure)) {
00437                         /*! ist datei also loeschen */
00438                         unlink($structure);
00439                         /*! ausgabe fuer debugger , datei geloescht */
00440                         if ($debugging) $out["errors"] .= "Datei ".$filename." wurde gelöscht ";
00441                         /*! datei geloescht loggen */
00442                         logThis("deleted file",$structure);
00443                 } else {
00444                         /*! error ausgabe Datei löschen */
00445                         $out["errors"] .= "Datei existiert nicht ";
00446                 }
00447         }       else {
00448                         /*! error ausgabe datei gibt es nicht */
00449                         $out["errors"] .= "Datei oder Verzeichnis existiert nicht ";
00450         }
00451 }
00452 /*! \brief lookup actual Protektion username and Time
00453  *      \param $filepath Datei Pfad
00454  */
00455 function showprotection($filepath) {
00456         /*! globale variablen festlegen */
00457         global $out;
00458         global $used;
00459         /*! arbeitsvariablen setzen */
00460         $haveusername = "";
00461         $havedatetime = array("","");
00462         /*! alle protection datas durchgehen */
00463         foreach ($used["protectiondatas"] as $pdata) {
00464                 /*! check ob pfad vorhanden */
00465                 if ($filepath == $pdata[1]) {
00466                         /*! pfad vorhanden , zwischenpreichern name */
00467                         $haveusername = $pdata[2];
00468                         /*! zwischenpreichern datum und zeit als array  */
00469                         $havedatetime = explode(" ",$pdata[3]);
00470                 }
00471         }
00472         /*! protection daten setzen */
00473         $protectinfo = array(   "user"=>$haveusername,
00474                                                         "date"=>$havedatetime[0],
00475                                                         "time"=>$havedatetime[1]
00476                                                 );
00477         /*! rueckgabe protection info array */
00478         return $protectinfo;
00479 }
00480 /*! \brief File Permissions human readable unix style
00481  *      \param $filepath Datei Pfad
00482  *      \return $allperms rechte lesbar , sonst default array
00483  */
00484 function getperms($filepath) {
00485         /*! globale variablen festlegen */
00486         global $out;
00487         /*! arbeitsvariable sdefault setzen */
00488         $allperms = array (     "typ" =>"",
00489                                                 "owner"=> array(        "r"=>"",
00490                                                                                         "w"=>"",
00491                                                                                         "x"=>""),
00492                                                 "group"=> array(        "r"=>"",
00493                                                                                         "w"=>"",
00494                                                                                         "x"=>""),
00495                                                 "other"=> array(        "r"=>"",
00496                                                                                         "w"=>"",
00497                                                                                         "x"=>"")
00498                                         );
00499         /*! ueberpruefen ob datei existiert */
00500         if (file_exists($filepath)) {
00501                 /*! datei rechte holen */
00502                 $perms = fileperms($filepath);
00503                 if (($perms & 0xC000) == 0xC000) {
00504                         $allperms["typ"]= 's'; /*! Socket */
00505                 } elseif (($perms & 0xA000) == 0xA000) {
00506                         $allperms["typ"]= 'l'; /*! Symbolic Link */
00507                 } elseif (($perms & 0x8000) == 0x8000) {
00508                         $allperms["typ"]= '-'; /*! Regular */
00509                 } elseif (($perms & 0x6000) == 0x6000) {
00510                         $allperms["typ"]= 'b'; /*! Block special */
00511                 } elseif (($perms & 0x4000) == 0x4000) {
00512                         $allperms["typ"]= 'd'; /*! Directory */
00513                 } elseif (($perms & 0x2000) == 0x2000) {
00514                         $allperms["typ"]= 'c'; /*! Character special */
00515                 } elseif (($perms & 0x1000) == 0x1000) {
00516                         $allperms["typ"]= 'p'; /*! FIFO pipe */
00517                 } else {
00518                         $allperms["typ"]= 'u'; /*! Unknown */
00519                 }
00520                 /*! Owner lesen */
00521                 $allperms["owner"]["r"]= (($perms & 0x0100) ? 'r' : '-');
00522                 /*! Owner schreiben */
00523                 $allperms["owner"]["w"]= (($perms & 0x0080) ? 'w' : '-');
00524                 /*! Owner ausfuehren */
00525                 $allperms["owner"]["x"]= (($perms & 0x0040) ? (($perms & 0x0800) ? 's' : 'x' ) : (($perms & 0x0800) ? 'S' : '-'));
00526                 /*! Group lesen */
00527                 $allperms["group"]["r"]= (($perms & 0x0020) ? 'r' : '-');
00528                 /*! Group schreiben */
00529                 $allperms["group"]["w"]= (($perms & 0x0010) ? 'w' : '-');
00530                 /*! Group ausfuehren */
00531                 $allperms["group"]["x"]= (($perms & 0x0008) ? (($perms & 0x0400) ? 's' : 'x' ) : (($perms & 0x0400) ? 'S' : '-'));
00532                 /*! Others lesen */
00533                 $allperms["other"]["r"]= (($perms & 0x0004) ? 'r' : '-');
00534                 /*! Others schreiben */
00535                 $allperms["other"]["w"]= (($perms & 0x0002) ? 'w' : '-');
00536                 /*! Others ausfuehren */
00537                 $allperms["other"]["x"]= (($perms & 0x0001) ? (($perms & 0x0200) ? 't' : 'x' ) : (($perms & 0x0200) ? 'T' : '-'));
00538         } else {
00539                 /*! fehler keine datei / berzeichnis vorhanden */
00540                 $out["errors"] .= "Datei oder Verzeichnis existiert nicht ";
00541         }
00542         /*! rueckgabe date rechte */
00543         return $allperms;
00544 }
00545 /*! \brief zeigt file infos
00546  *      \param $filepath Datei Pfad
00547  *      \return $finfo Datei Informationen
00548  */
00549 function getFileInfo($filepath) {
00550         /*! globale variablen festlegen */
00551         global $out;
00552         /*! arbeitsvariable setzen */
00553         $finfo = array();
00554         /*! ueberpruefen ob datei existiert */
00555         if (file_exists($filepath)) {
00556                 /*! datum und zeit von erzeugt und modifiziert eintragen */
00557                 $finfo = array("create"=>array("date"=>date("Y-m-d", filectime($filepath)),
00558                                                                         "time"=>date("H:i", filectime($filepath))
00559                                                                         ),
00560                                         "modifie"=>array("date"=>date("Y-m-d", filemtime($filepath)),
00561                                                                         "time"=>date("H:i", filemtime($filepath))
00562                                                                         )
00563                                         );
00564         }       else {
00565                 /*! fehler keine datei / berzeichnis vorhanden */
00566                 $out["errors"] .= "Datei oder Verzeichnis existiert nicht ";
00567         }
00568         /*! rueckgabe datei datum info */
00569         return $finfo;
00570 }
00571 /*! \brief check dir may hafe files
00572  *      \param $aktueller_pfad aktueller Datei Pfad
00573  *      \return $entryfound anzahl gefundener Einträge
00574  */
00575 function checkDir($aktueller_pfad) {
00576         /*! arbeitsvariable setzen */
00577         $entryfound = false;
00578         /*! directory oeffnen */
00579         if ($dh = opendir($aktueller_pfad)) {
00580                 /*! zaehler fuer eintraege negative */
00581                 $entrycount = -1;
00582                 /*! solange eintrag in directory und kein entry gefunden */
00583                 while ((($file = readdir($dh)) !== false) AND !$entryfound ) {
00584                         /*! nur wenn wirklich ein eintrag dann eintrag gefunden */
00585                         if ($file != "." and $file != "..") {$entryfound = true;}
00586                 }
00587                 /*! datei schliessen */
00588                 closedir($dh);
00589         }
00590         /*! rueckgabe eintrag vorhanden (wahr/falsch) */
00591         return $entryfound;
00592 }
00593 /*! \brief Directory Aufbau
00594  *      \param $aktueller_pfad aktueller Datei Pfad
00595  *      \return $thedir das aktuelle Direktory als Array
00596  */
00597 function getDir($aktueller_pfad) {
00598         /*! globale variablen festlegen */
00599         global $out;
00600         global $used;
00601         global $FS;
00602         global $debugging;
00603         global $thedir;
00604         global $INSTALL_DIR;
00605         /*! protection daten aus protectionfile lesen */
00606         $used["protectiondatas"]=getprotectiondata();
00607         /*! objekt default fuer directory daten */
00608         $dirset = array(        "name"=>"",
00609                                                 "filename"=>"",
00610                                                 "path"=>"",
00611                                                 "size"=>"",
00612                                                 "info"=>array(  "create"=>array("date"=>"",
00613                                                                                                                 "time"=>""),
00614                                                                                 "modifie"=>array("date"=>"",
00615                                                                                                                 "time"=>"")
00616                                                                          ),
00617                                                 "rights"=>array (       "typ" =>"",
00618                                                                                         "owner"=> array(        "r"=>"",
00619                                                                                                                                 "w"=>"",
00620                                                                                                                                 "x"=>""),
00621                                                                                         "group"=> array(        "r"=>"",
00622                                                                                                                                 "w"=>"",
00623                                                                                                                                 "x"=>""),
00624                                                                                         "other"=> array(        "r"=>"",
00625                                                                                                                                 "w"=>"",
00626                                                                                                                                 "x"=>"")
00627                                                                                 ),
00628                                                 "protection"=> array(   "user"=>"",
00629                                                                                                 "date"=>"",
00630                                                                                                 "time"=>""
00631                                                                                         ),
00632                                                 "options"=> array(      "delete"=>"",
00633                                                                                         "protect"=>"",
00634                                                                                         "unprotect"=>"",
00635                                                                                         "upload"=>""
00636                                                                                 ),
00637                                                 "lastlog"=>array(       "entry"=>"",
00638                                                                                         "date"=>"",
00639                                                                                         "time"=>"",
00640                                                                                         "user"=>"",
00641                                                                                         "action"=>""
00642                                                                                 )
00643                                         );
00644         /*! auf directory preufen */
00645         if (is_dir($aktueller_pfad)) {
00646                 /*! debugg ausgabe ist directory */
00647                 if ($debugging) { $out["errors"] .= "ist directory".$aktueller_pfad."<br>";     }
00648                 /*! directory oeffnen */
00649                 if ($dh = opendir($aktueller_pfad)) {
00650                         /*! eintrag zaehler negativ */
00651                         $entrycount = -1;
00652                         /*! solange eintrag in directory */
00653                         while (($file = readdir($dh)) !== false) {
00654                                 /*! eintrag zaehler incrementieren */
00655                                 ++$entrycount;
00656                                 /*! fuer spezial directory eintraege */
00657                                 if ($file == "." or $file == "..") {
00658                                         /*! fuer upperDir nur wenn nicht home directory */
00659                                         if ($file == ".." and ( $used['path']."/" != $used['pathnow'] )) {
00660                                                 /*! default objekt fuer direktory erzeugen */
00661                                                 $thedir[$entrycount]=$dirset;
00662                                                 /*! filename eintragen */
00663                                                 $thedir[$entrycount]["filename"] = $file;
00664                                                 /*! top pfad realtive erzeugen */
00665                                                 $urlpfadtop = preg_replace("$".quotemeta($used['path'])."/$","",$used['pathnow']);
00666                                                 /*! pfad bereinigen */
00667                                                 $urlpfadtop = trim($urlpfadtop,'/');
00668                                                 /*! pfad trennen bei / */
00669                                                 $arraypfad = explode("/",$urlpfadtop);
00670                                                 /*! letzten ordner entfernen */
00671                                                 array_pop($arraypfad);
00672                                                 /*! pfad worder zusammensetzen */
00673                                                 $urlpfadtop = implode("/",$arraypfad);
00674                                                 /*! upper ordner link */
00675                                                 $thedir[$entrycount]["name"] = "<a href=\"/".$INSTALL_DIR."/?pathnow=".$urlpfadtop."\">upper dir</a>";
00676                                                 /*! typ z zum sortieren setzen */
00677                                                 $thedir[$entrycount]["rights"]["typ"]="z";
00678                                         }
00679                                         /*! fuer thisDir */
00680                                         if ($file == ".") {
00681                                                 /*! default objekt fuer direktory erzeugen */
00682                                                 $thedir[$entrycount]=$dirset;
00683                                                 /*! filename eintragen */
00684                                                 $thedir[$entrycount]["filename"] = $file;
00685                                                 /*! relativen pfad erzeugen */
00686                                                 $urlpfadtop = preg_replace("$".quotemeta($used['path'])."/$","",$used['pathnow']);
00687                                                 /*! link fuer thisDir */
00688                                                 $thedir[$entrycount]["name"] = "<a href=\"/".$INSTALL_DIR."/?pathnow=".$urlpfadtop."\">this dir</a>";
00689                                                 /*! typ y zum sortieren setzen */
00690                                                 $thedir[$entrycount]["rights"]["typ"]="y";
00691                                         }
00692                                 } else {
00693                                         /*! kein spezial directory eintrag */
00694                                         /*! default objekt fuer direktory erzeugen */
00695                                         $thedir[$entrycount]=$dirset;
00696                                         /*! filename eintragen */
00697                                         $thedir[$entrycount]["filename"] = $file;
00698                                 }
00699                                 /*! aktuellen pfad erzeugen */
00700                                 $filepath = $aktueller_pfad . $file;
00701                                 /* manage flags for managed access */
00702                                 $isuser = false;
00703                                 $isprotected = false;
00704                                 /* check if protected and user */
00705                                 foreach ($used["protectiondatas"] as $pdata) {
00706                                         /*! fals pfad in protection data */
00707                                         if ($filepath == $pdata[1]) {
00708                                                 /*! ist protected whar */
00709                                                 $isprotected = true;
00710                                                 /*! fals username in protection data */
00711                                                 if ($used["username"] == $pdata[2]) {
00712                                                         /*! ist user wahr */
00713                                                         $isuser = true;
00714                                                 }
00715                                         }
00716                                 }
00717                                 /*! nur wenn keine spezial directory eintraege */
00718                                 if ($file != "." and $file != "..") {
00719                                         /*! checken ob directory */
00720                                         if (is_dir($filepath)) {
00721                                                 /*! realtiven pfad erzeugen */
00722                                                 $urlpfad = preg_replace("|".$used['path']."/|","",$filepath);
00723                                                 /*! link  fuer verzeichnis */
00724                                                 $thedir[$entrycount]["name"]= "<a href=\"/".$INSTALL_DIR."/?pathnow=".$urlpfad."\">".$file."</a>";
00725                                                 /*! pverzeichnisfad eintragen */
00726                                                 $thedir[$entrycount]["path"]= $filepath;
00727                                                 /*! verzeichnis groesse ignorieren */
00728                                                 $thedir[$entrycount]["size"] = "";
00729                                                 /*! verzeichnis datum infos */
00730                                                 $thedir[$entrycount]["info"] = getFileInfo($filepath);
00731                                                 /*! verzeichnis rechte */
00732                                                 $thedir[$entrycount]["rights"] = getperms($filepath);
00733                                                 /*! verzeichnis protekt status */
00734                                                 $thedir[$entrycount]["protection"] = showprotection($filepath);
00735                                                 /*! wenn nicht protekted und direktory  */
00736                                                 if ( !$isprotected and !checkDir($filepath)) {
00737                                                         /*! loesch button form eintragen  */
00738                                                         $thedir[$entrycount]["options"]["delete"]= formlink("option","optiondel".$entrycount,"optiondel","folderoption","del","del",$file,$size="0");
00739                                                 }
00740                                         }
00741                                         /*! ist datei */
00742                                         if ( is_file($filepath) ) {
00743                                                 /*! ist geschuetzt durch user */
00744                                                 if ($isprotected AND $isuser) {
00745                                                         /*! download button eintragen */
00746                                                         $thedir[$entrycount]["name"]= formlink("link","downloadfile","downloadfile".$entrycount,"download","file",$file,"","0");
00747                                                 } else {
00748                                                         /*! ist nicht geschuetzt also nur text  */
00749                                                         $thedir[$entrycount]["name"]= $file;
00750                                                 }
00751                                                 /*! pfad eintragen */
00752                                                 $thedir[$entrycount]["path"]= $filepath;
00753                                                 /*! dateigroesse eintragen */
00754                                                 $thedir[$entrycount]["size"] = filesize($filepath);
00755                                                 /*! datei infos eintragen */
00756                                                 $thedir[$entrycount]["info"] = getFileInfo($filepath);
00757                                                 /*! datei rechte eintragen */
00758                                                 $thedir[$entrycount]["rights"] = getperms($filepath);
00759                                                 /*! datei ptotektion  eintragen */
00760                                                 $thedir[$entrycount]["protection"] = showprotection($filepath);
00761                                                 /*! wenn nicht protected */
00762                                                 if (!$isprotected) {
00763                                                         /*! dann loesch button eintragen */
00764                                                         $thedir[$entrycount]["options"]["delete"]= formlink("option","optiondel".$entrycount,"optiondel","fileoption","del","del",$file,$size="0");
00765                                                         /*! dann protect button eintragen */
00766                                                         $thedir[$entrycount]["options"]["protect"]= formlink("option","optionprotect".$entrycount,"optionprotect","fileoption","protect","use",$file,$size="0");
00767                                                 }
00768                                                 /*! wenn protected durch user */
00769                                                 if ($isprotected AND $isuser) {
00770                                                         /*! dann unprotekt button eintragen */
00771                                                         $thedir[$entrycount]["options"]["unprotect"]= formlink("option","optionunprotect".$entrycount,"optionunprotect","fileoption","unprotect","free",$file,$size="0");
00772                                                         /*! dann upload button eintragen */
00773                                                         $thedir[$entrycount]["options"]["upload"]= formlink("file","optionupdate".$entrycount,"optionupdate","fileoption","update","update",$file,"5");
00774                                                 }
00775                                         }
00776                                 }
00777                         }
00778                         /*! directory schliessen */
00779                         closedir($dh);
00780                         /*! letzten log eintrag holen */
00781                         getlogdata($thedir);
00782                 } else {
00783                         /*! error ausgabe aktuelles Verzeichnis zugriff */
00784                         $out["errors"] .= "konnte auf aktuelles Verzeichnis nicht zugreifen ";
00785                 }
00786         } else {
00787                 /*! error ausgabe kein aktuelles Verzeichnis vorhanden */
00788                 $out["errors"] .= "kein aktuelles Verzeichnis";
00789         }
00790         /*! rueckgabe des directorys */
00791         return $thedir;
00792 }
00793 /*! \brief readable filesize
00794  *      \param $size Datei Grösse in Bytes
00795  *      \return $fomatedsize Dateigrösse in Dezimal und mit grösster Einheit
00796  */
00797 function format_size($size) {
00798         /*! alle moeglichen Bezeichnungen setzen */
00799         $sizes = array(" b", " kb", " M", " G", " T", " PB", " EB", " ZB", " YB");
00800         /*! arbeitsvariable setzen */
00801         $fomatedsize ="";
00802         /*! wenn groesse nicht null */
00803     if ($size != 0) {
00804                 /*! berechne dezimal groesse */
00805                 $fomatedsize = round($size/pow(1024, ($i = floor(log($size, 1024)))), 2) . $sizes[$i];
00806         }
00807         /*! rueckgabe lesbare groesse */
00808     return $fomatedsize;
00809 }
00810 /*! \brief form link build
00811  *      \param $typ Formular Typ (file,input,option)
00812  *      \param $id Formular ID
00813  *      \param $name Formular Name
00814  *      \param $what Formular ORDER 1 Teil
00815  *      \param $action  Formular ORDER 2 Teil
00816  *      \param $about Formular Submit Botton (Datenfeld bei Vorgabe)
00817  *      \param $field Formular Datenfeld (eingabe , datei auswahl)
00818  *      \param $size Formular Datenfeld länge (default 0)
00819  *      \return $form HTML Formular
00820  */
00821 function formlink($typ,$id,$name,$what,$action,$about,$field = "",$size="0") {
00822         /*! globale variablen festlegen */
00823         global $out;
00824         global $sid;
00825         global $used;
00826         /*! arbeitsvariablen setzen */
00827         $multipart ="";
00828         $form  ="\n";
00829         /*! wenn fuer datei upload dann multipart form setzen */
00830         if ($typ == "file") {$multipart = "enctype=\"multipart/form-data\"";}
00831         /*! form tag bauen */
00832         $form .="\t\t<form id=\"".$id."\" action=\"?".$used["sidurl"]."\" name=\"".$name."\" ".$multipart." method=\"post\">"."\n";
00833         /*! sid feld */
00834         $form .= $used["sidfield"] ;
00835         /*! aktueller pfad */
00836         $form .="\t\t\t"."<input id=\"".$id."pathnow\" name=\"pathnow\" value=\"".$used['pathnow']."\" type=\"hidden\" />"."\n";
00837         /*! order what feld mit parameter */
00838         $form .="\t\t\t"."<input id=\"".$id."what\" name=\"what\" value=\"".$what."\" type=\"hidden\" />"."\n";
00839         /*! order action feld mit parameter */
00840         $form .="\t\t\t"."<input id=\"".$id."action\" name=\"action\" value=\"".$action."\" type=\"hidden\" />"."\n";
00841         /*! sende button  mit parameter */
00842         $form .="\t\t\t"."<input id=\"".$id."about\" name=\"about\" value=\"".$about."\" type=\"submit\" />"."\n";
00843         /*! wenn $field nicht leer */
00844         if ($field !="") {
00845                 /*! und typ input */
00846                 if ($typ == "input") {
00847                         /*! dann leeres input feld */
00848                         $form .="\t\t\t"."<input id=\"".$id."field\" name=\"field\" value=\"\" type=\"input\" size=\"".$size."\" />"."\n";
00849                 }
00850                 /*! und typ file */
00851                 if ($typ == "file") {
00852                         /*! dann datei upload feld */
00853                         $form .="\t\t\t"."<input id=\"file\" name=\"file\" type=\"file\" size=\"".$size."\" />"."\n";
00854                         /*! wenn keine neue datei */
00855                         if ($field !="newfile") {
00856                                 /*! dann feld mit parameter */
00857                                 $form .="\t\t\t"."<input id=\"".$id."field\" name=\"field\" value=\"".$field."\" type=\"hidden\" size=\"".$size."\" />"."\n";
00858                         }
00859                 }
00860                 /*! und typ option */
00861                 if ($typ == "option") {
00862                         /*! dann feld mit parameter */
00863                         $form .="\t\t\t"."<input id=\"".$id."field\" name=\"field\" value=\"".$field."\" type=\"hidden\" size=\"".$size."\" />"."\n";
00864                 }
00865         }
00866         /*! form tag schliessen */
00867         $form .="\t\t</form>"."\n";
00868         /*! rueckgabe des formular strings */
00869         return $form;
00870 }
00871 /*! \brief Ausgabe Menue Allgemein:neuen Ordner erzeugen,Datei uploaden
00872  *
00873  */
00874 function getactionadminmenue() {
00875         /*! globale variablen festlegen */
00876         global $out;
00877         global $sid;
00878         global $used;
00879         /*! arbeits variable default setzen */
00880         $outmenu="";
00881         /*! wenn angemeldeter user */
00882         if ($used["userlevel"] > 99 and $used["userlevel"] < 499) {
00883                 /*! form fuer neuen user  */
00884 $outmenu .= <<<ADMINMENU
00885         <div class="adminbox">
00886         <p class="yellowbk">Administration :</p>
00887         <form id="addnewuser" action="?$used[sidurl]" name="addnewuser"  method="post" class="addnewuser">
00888 Admin -> Add NewUser :<input id="addnewusername" name="pathnow" value="$used[pathnow]" type="hidden" />
00889         <input id="addnewuserwhat" name="what" value="usermng" type="hidden" />
00890         <input id="addnewuseraction" name="action" value="addnew" type="hidden" />
00891         Name:<input id="addnewuseruname" name="uname" value="" type="input" size="20" />
00892         Login:<input id="addnewuserulogin" name="ulogin" value="" type="input" size="20" />
00893         Pass:<input id="addnewuserupass" name="upass" value="" type="password" size="20" />
00894         Pass:<input id="addnewuserupassproof" name="upassproof" value="" type="password" size="20" />
00895         <input id="addnewuserabout" name="about" value="add new user" type="submit" />
00896 </form>
00897 </div>
00898 ADMINMENU;
00899         }
00900         /*! rueckgabe des form strings */
00901         return $outmenu;
00902 }
00903 /*! \brief Ausgabe Menue Allgemein:neuen Ordner erzeugen,Datei uploaden
00904  *
00905  */
00906 function getactionmenue() {
00907         /*! globale variablen festlegen */
00908         global $out;
00909         global $sid;
00910         global $used;
00911         /*! allgemeines menu */
00912         $out["menu"] .= "<!-- menue -->"."\n";
00913         $out["menu"] .="<div id=\"newfolderupload\" class=\"newfolderupload\">";
00914         $out["menu"] .= formlink("input","newfolder","newfolder","menue","newfolder","neuer Ordner","foldername","20");
00915         $out["menu"] .= formlink("file","newupload","newupload","upload","newfile","upload neue Datei","newfile","40");
00916         $out["menu"] .="</div>";
00917 }
00918 /*! \brief upload function
00919  *      \param $update Stausflag (true = vorhanden ,false = neu) für Dateiupload
00920  *      \return $uploaded Status Dateiupload
00921  */
00922  function GetUploadFile($update) {
00923         /*! globale variablen festlegen */
00924         global $out;
00925         global $used;
00926         global $FS;
00927         global $debugging;
00928         /*! arbeits variablen default setzen */
00929         $uploaded=false;
00930         /*! schlater fuer kopieren */
00931         $copythefile = true;
00932         /*! pruefen ob datei hochgeladen wurde */
00933         if(is_uploaded_file($_FILES["file"]["tmp_name"])) {
00934                         /*! Datei pfad zum kopieren */
00935                         $uploadtocopy = $used["pathnow"].$_FILES["file"]["name"];
00936                         /*! keine Datei aber update also nicht kopieren */
00937                         if (!file_exists($uploadtocopy) AND $update )  { $copythefile = false; };
00938                         /*! Datei aber kein update also nicht kopieren */
00939                         if (file_exists($uploadtocopy) AND !$update )  {$copythefile = false;}
00940                         /*! pruefen ob datei existiert und ein update */
00941                         if (file_exists($uploadtocopy) AND $update )  {
00942                                 /*! protekt daten holen */
00943                                 $protectdata = checkprotection($uploadtocopy,true);
00944                                 /*! wenn status falsch dann nicht kopieren */
00945                                 if (!$protectdata["status"] )  { $copythefile = false; } ;
00946                                 /*!  wenn upload name nicht paramter name dann nicht kopieren */
00947                                 if ($_FILES["file"]["name"] != $_POST["field"]) { $copythefile = false; };
00948                                 /*! wenn status ok und username nicht protektor dann nicht kopieren */
00949                                 if ($protectdata["status"] AND ($protectdata["username"] != $used["username"]))  { $copythefile = false; };
00950                         };
00951                         /*! wenn kopieren erlaubt */
00952                         if ($copythefile) {
00953                                 /*! dann kopier datei */
00954                                 if(copy($_FILES["file"]["tmp_name"], $uploadtocopy)) {
00955                                         /*! es wurde upgeloaded */
00956                                         $uploaded = true;
00957                                         /*! auf update pruefen */
00958                                         if (!$update) {
00959                                                 /*! kein update also upload in loggen  */
00960                                                 logThis("uploaded file",$uploadtocopy);
00961                                         } else {
00962                                                 /*! ist update also update loggen */
00963                                                 logThis("updated file",$uploadtocopy);
00964                                         }
00965                                 } else {
00966                                         /*! error ausgabe kann upload datei nicht kopieren */
00967                                         $out["errors"] .= "cant copy uploaded file";
00968                                 }
00969                         }
00970         } else {
00971                 /*! error akeine datei zum uploaden da */
00972                 $out["errors"] .= "no file to upload sorry";
00973         }
00974         /*! rueckgabe upload status */
00975         return $uploaded;
00976 }
00977 /*! \brief unprotect a file
00978  *      \param $filename Datei Namen
00979  */
00980 function unprotectaFile($filename) {
00981         /*! globale variablen festlegen */
00982         global $out;
00983         global $used;
00984         global $FS;
00985         global $debugging;
00986         /*! pfad fuer unprotekt datei */
00987         $filetounprotect = $used["pathnow"].$filename;
00988         /*! check protektion */
00989         $fileprotected = checkprotection($filetounprotect);
00990         /*! wenn protekt */
00991         if ($fileprotected) {
00992                 /*! dann datei protektion aufheben */
00993                 unprotectFile($filetounprotect);
00994         } else {
00995                 /*! error ausgabe datei protektion fehler */
00996                 $out["errors"] .= " sorry file is unprotected <br>";
00997         }
00998 }
00999 /*! \brief unprotect file, delete the file from the dbfile
01000  *      \param $filetounprotect Datei Pfad
01001  */
01002 function unprotectFile($filetounprotect) {
01003         /*! globale variablen festlegen */
01004         global $out;
01005         global $used;
01006         global $FS;
01007         global $debugging;
01008         /*! oeffen der protektion datei zum lesen */
01009         $fh = fopen($used["protectiondb"], 'r');
01010         /*! neue db datei inhalt default */
01011         $newdbfilecontent = "";
01012         /*! datei handle auf fehler pruefen */
01013         if($fh == false) {
01014         $out["errors"] .= "ERROR: File not found -> ".$used["userlogindb"]."<br>";
01015         }else {
01016         /*! datei geoffnet , solange bis datei ende ist  */
01017         while (!feof($fh)){
01018                         /*! zeile einlesen */
01019                    $line = fgets ($fh);
01020                    /*! auf fehler beim zeile einlesen pruefen */
01021                    if ($line===FALSE) {
01022                         /*! fuer debugging fehler beim zeile lesen ausgeben */
01023                         if ($debugging)  $out["errors"] .= " cant read line <br>";
01024                    } else {
01025                         /*! kein fehler beim lesen also regexpression fuer datei erzeugen */
01026                         $thefilepathtag = "|<filepath>".quotemeta($filetounprotect)."</filepath>|";
01027                         /*! wenn datei pfad nicht gefunden dann zeile zur neuen db hinzufuegen  */
01028                          if (!preg_match($thefilepathtag,$line)) {  $newdbfilecontent .= $line; }
01029                    };
01030         }
01031         /*! datei schliessen */
01032     fclose($fh);
01033         }
01034         /*! pruefen ob datei zum schreiben geoeffnet werden kann */
01035     if (!$fh = fopen($used["protectiondb"], 'w')) {
01036                 /*! error ausgabe datenbank datei nicht schreibbar */
01037         $out["errors"] .= "Cannot open db file to write stuff  <br>";
01038     } else {
01039                 /*! wenn geoeffnet dann schreibe neue db */
01040                 if (fwrite($fh, $newdbfilecontent) === FALSE) {
01041                         /*! error ausgabe fehler beim schreiben der datenbank */
01042                         $out["errors"] .= "Cannot rewrite  db file <br>";
01043                 }
01044                 /*! datei schliessen */
01045                 fclose($fh);
01046         }
01047         /*! datei unprotekt loggen */
01048         logThis("file unprotected",$filetounprotect);
01049 }
01050 /*! \brief protect a file , write into db file
01051  *      \param $filename Datei Name
01052  */
01053 function protectaFile($filename) {
01054         /*! globale variablen festlegen */
01055         global $out;
01056         global $used;
01057         global $FS;
01058         global $debugging;
01059         /*! pfad fuer unprotekt datei */
01060         $filetoprotect = $used["pathnow"].$filename;
01061         /*! check protektion */
01062         $fileprotected = checkprotection($filetoprotect);
01063         /*! wenn nicht protekt */
01064         if (!$fileprotected) {
01065                 /*! wdann protekt datei  */
01066                 protectFile($filetoprotect);
01067         } else {
01068                 /*! error ausgabe datei schon geschützt */
01069                 $out["errors"] .= " sorry file is protected , please wait or unprotect <br>";
01070         }
01071 }
01072 /*! \brief check protection of a file
01073  *      \param $filetoprotect Datei Pfad
01074  *      \param $typ rückgabe typ (default = false)
01075  *      \return $fileprotectiondata Datei Angaben in Datenbankdatei
01076  */
01077 function checkprotection($filetoprotect,$typ=false) {
01078         /*! globale variablen festlegen */
01079         global $out;
01080         global $used;
01081         global $FS;
01082         global $debugging;
01083         /*! default protektion objekt */
01084         $fileprotectiondata = array("status"=>false,
01085                                                                 "username"=>""
01086                                                                 );
01087         /*! default user daten */
01088         $userdata = array();
01089         /*! datei zum lesen oeffnen */
01090         $fh = fopen($used["protectiondb"], 'r');
01091         /*! pruefen ob fehler beim oeffnen */
01092         if($fh == false){
01093         $out["errors"] .= "ERROR: File not found -> ".$used["userlogindb"]."<br>";
01094         }else {
01095         /*! datei geoeffnet also solange bis datei ende */
01096         while (!feof($fh)){
01097                 /*! zeile einlesen */
01098                    $line= fgets ($fh);
01099                    /*! auf fehler beim zeile einlesen pruefen */
01100                    if ($line===FALSE) {
01101                    /*! fuer debugging fehler beim zeile lesen ausgeben */
01102                         if ($debugging)  $out["errors"] .= " cant read line <br>";
01103                    } else {
01104                    /*! regexpression fur datei pfad */
01105                         $thefilepathtag = "|<filepath>(".quotemeta($filetoprotect).")</filepath>|";
01106                         /*! wenn tag in Zeile */
01107                         if (preg_match($thefilepathtag,$line)) {
01108                                 /*! dann status wahr */
01109                                 $fileprotectiondata["status"] = true;
01110                                 /*! regexpression fuer user */
01111                                 $theusernametag = "|<user>(.*)</user>|";
01112                                 /*! user name  extrahieren */
01113                                 $founduser = preg_match($theusernametag,$line,$userdata);
01114                                 /*! user name eintragen  */
01115                                 $fileprotectiondata["username"]=$userdata[1];
01116                         };
01117                    };
01118         }
01119         /*! datei schliessen */
01120     fclose($fh);
01121         }
01122         /*! rueckgabe auf parameter basierend */
01123         if ($typ) {
01124                 /*! wenn typ wahr dann als objekt */
01125                 return $fileprotectiondata;
01126         } else {
01127                 /*! wenn typ falsch dann als boolean */
01128                 return $fileprotectiondata["status"];
01129         }
01130 }
01131 /*! \brief check user login file
01132  *      \param $userlogin der Loginname
01133  *      \param $userpass das Loginpasswort
01134  */
01135 function checkuserlogin($userlogin,$userpass) {
01136         /*! globale variablen festlegen */
01137         global $out;
01138         global $used;
01139         global $FS;
01140         global $debugging;
01141         /*! default user level */
01142         $userlevel = 0;
01143         /*! login datei zum lesen oeffnen  */
01144         $fh = fopen($used["userlogindb"], 'r');
01145         /*! wenn fehler beim lesen */
01146         if($fh == false){
01147                 /*! dann error ausgeben */
01148         $out["errors"] .= "ERROR: File not found -> ".$used["userlogindb"]."<br>";
01149         }else {
01150                 /*! datei geeofnet , solange bis datei ende */
01151         while (!feof($fh)){
01152                         /*! zeile einlesen */
01153                    $line= fgets ($fh);
01154                    /*! auf fehler beim zeile einlesen pruefen */
01155                    if ($line===FALSE) {
01156                         /*! fuer debugging fehler beim zeile lesen ausgeben */
01157                         if ($debugging)  $out["errors"] .= " cant read line <br>";
01158                    } else {
01159                         /*! userloign verschluesseln */
01160                         $usermd5login = md5($userlogin);
01161                         /*! regexpression userlogin tag */
01162                         $thelogintag = "|<userlogin>".quotemeta($usermd5login)."</userlogin>|";
01163                         /*! wenn regexpression user login tag in zeile */
01164                         if (preg_match($thelogintag,$line)) {
01165                                 /*! dann  password  fur user verschluesseln */
01166                                 $usermd5pass = md5($userpass."isuser");
01167                                 /*! regexpression userpass tag */
01168                                 $thepasstag = "|<userpass>".quotemeta($usermd5pass)."</userpass>|";
01169                                 /*! wenn regexpression userpass tag in zeile */
01170                                 if (preg_match($thepasstag,$line)) {
01171                                         /*! dann user level 500 , normaler user */
01172                                         $userlevel = 500;
01173                                 }
01174                                 /*! kein user dann  password  fur admin verschluesseln */
01175                                 $usermd5pass = md5($userpass."isadmin");
01176                                 /*! regexpression userpass tag */
01177                                 $thepasstag = "|<userpass>".quotemeta($usermd5pass)."</userpass>|";
01178                                 /*! wenn regexpression userpass tag in zeile */
01179                                 if (preg_match($thepasstag,$line)) {
01180                                         /*! dann user level 100 , admin user */
01181                                         $userlevel = 100;
01182                                 }
01183
01184                                 /*! nur fuer user */
01185                                 if ($userlevel > 99) {
01186                                         /*! regexpression username tag */
01187                                         $theusertag = "|<username>(.*)</username>|";
01188                                         /*! extrahieren des usernamens */
01189                                         $gotit = preg_match($theusertag,$line,$thisusersname);
01190                                         /*! username wurde extrahiert */
01191                                         if ($gotit > 0 ) {
01192                                                 /*! dann user name lesen */
01193                                                 $used["username"] = $thisusersname[1];
01194                                                 /*! dann user level lesen */
01195                                                 $used["userlevel"] = $userlevel;
01196                                         }
01197                                 }
01198                         };
01199                    };
01200         };
01201         /*! datei schliessen */
01202     fclose($fh);
01203         }
01204 }
01205 /*! \brief change user login file
01206  *      \param $userlogin der Loginname
01207  *      \param $userpass das Loginpasswort
01208  *      \param $newpass das neue Loginpasswort
01209  */
01210 function changeuserlogin($userlogin,$userpass,$newpass) {
01211         /*! globale variablen festlegen */
01212         global $out;
01213         global $used;
01214         global $FS;
01215         global $debugging;
01216         /*! arbeits variablen default */
01217         $newpassstring = "";
01218         $addnewuserline = "";
01219         $alluserslines ="";
01220         /*! user level default 0 */
01221         $userlevel = 0;
01222         /*! login datei zum lesen oeffnen  */
01223         $fh = fopen($used["userlogindb"], 'r');
01224         /*! wenn fehler beim lesen */
01225         if($fh == false){
01226                 /*! dann error ausgeben */
01227                 $out["errors"] .= "ERROR: File not found -> ".$used["userlogindb"]."<br>";
01228         }else {
01229         /*! datei geeofnet , solange bis datei ende */
01230         while (!feof($fh)){
01231                 /*! zeile einlesen */
01232                    $line= fgets ($fh);
01233                    /*! auf fehler beim zeile einlesen pruefen */
01234                    if ($line===FALSE) {
01235                         /*! fuer debugging fehler beim zeile lesen ausgeben */
01236                                 if ($debugging)  $out["errors"] .= " cant read line <br>";
01237                    } else {
01238                                 /*! regexpression fuer usernamen */
01239                                 $theunametag = "|<username>".quotemeta($used['username'])."</username>|";
01240                                 /*! wenn regexpression user login tag in zeile */
01241                                 if (preg_match($theunametag,$line)) {
01242                                         /*! login verschluesseln */
01243                                         $usermd5login = md5($userlogin);
01244                                         /*! regexpression fuer login name */
01245                                         $thelogintag = "|<userlogin>".quotemeta($usermd5login)."</userlogin>|";
01246                                         /*! wenn regexpression user login tag in zeile */
01247                                         if (preg_match($thelogintag,$line)) {
01248                                                 /*! passwort user verschluesseln */
01249                                                 $usermd5pass = md5($userpass."isuser");
01250                                                 /*! regexpression fuer user passwort user */
01251                                                 $thepasstag = "|<userpass>".quotemeta($usermd5pass)."</userpass>|";
01252                                                 /*! wenn regexpression user password tag in zeile */
01253                                                 if (preg_match($thepasstag,$line)) {
01254                                                         /*! dann neues passwort verschluesseln fuer user */
01255                                                         $newpassstring = md5($newpass."isuser");
01256                                                         /*! user level auf 500 setzen , normaler user */
01257                                                         $userlevel = 500;
01258
01259                                                 }
01260                                                 /*! passwort admin verschluesseln */
01261                                                 $usermd5pass = md5($userpass."isadmin");
01262                                                 /*! regexpression fuer user passwort  */
01263                                                 $thepasstag = "|<userpass>".quotemeta($usermd5pass)."</userpass>|";
01264                                                 /*! wenn regexpression user password tag in zeile */
01265                                                 if (preg_match($thepasstag,$line)) {
01266                                                         /*! dann neues passwort verschluesseln fuer admin */
01267                                                         $newpassstring = md5($newpass."isadmin");
01268                                                         /*! user level auf 100 setzen , admin user */
01269                                                         $userlevel = 100;
01270
01271                                                 }
01272                                                 /*! nur fuer richtigen  user */
01273                                                 if ($userlevel > 99) {
01274                                                         /*! username tag */
01275                                                         $theusernametag = "<username>".$used['username']."</username>";
01276                                                         /*! user login verschluesseln */
01277                                                         $usermd5ulogin = md5($userlogin);
01278                                                         /*! usern login tag */
01279                                                         $theuserlogintag ="<userlogin>".$usermd5ulogin."</userlogin>";
01280                                                         /*! user pass tag */
01281                                                         $theuserpasstag ="<userpass>".$newpassstring."</userpass>";
01282                                                         /*! tag zeile */
01283                                                         $taggedline = $theusernametag.$theuserlogintag.$theuserpasstag;
01284                                                         /*! eintragen in alluser  */
01285                                                         $alluserslines .= $taggedline."\n";
01286                                                 } else {
01287                                                                 /*! nicht user , also zeile uebernehmen  */
01288                                                                 $alluserslines .= $line;
01289                                                 }
01290                                         }
01291                                 } else {
01292                                 /*! nicht richtiger  user , also zeile uebernehmen  */
01293                                 $alluserslines .= $line;
01294                                 };
01295                    };
01296         };
01297         /*! datei schliessen */
01298     fclose($fh);
01299         }
01300         /*! nur fuer richtigen user */
01301         if ($userlevel > 99) {
01302                 /*! login datei zum schreiben oeffen */
01303            if (!$fh = fopen($used["userlogindb"], 'w')) {
01304                         /*! error ausgabe das öffnen der datenbank datei zum daten anhängen ist fehlgeschlagen */
01305                         $out["errors"] .= "Cannot open db file to append stuff  <br>";
01306                 } else {
01307                         /*! login datei geoefnet also schreibe inhalt */
01308                         if (fwrite($fh, $alluserslines) === FALSE) {
01309                                 /*! error ausgabe kann datenbank datei keine daten anhängen */
01310                                 $out["errors"] .= "Cannot write to db file to append stuff <br>";
01311                         } else {
01312                                 /* inhalt wurde geschrieben ausgabe */
01313                                 $out["errors"] .= "user changed password";
01314                                 /* inhalt wurde geschrieben loggen */
01315                                 logThis("changed userpass ",$used['username']);
01316                         }
01317                         /*! datei schliessen */
01318                         fclose($fh);
01319                 }
01320         } else {
01321                 /*! kein update erfolgt */
01322                 $out["errors"] .= "user password untouched";
01323         }
01324 }
01325 /*! \brief get protections from database file for pathnow
01326  *      \return $protections Protectionsdaten aus der Datenbank
01327  */
01328 function getprotectiondata() {
01329         /*! globale variablen festlegen */
01330         global $out;
01331         global $used;
01332         global $FS;
01333         global $debugging;
01334         $protections = array();
01335         /*! login datei zum lesen oeffnen  */
01336         $fh = fopen($used["protectiondb"], 'r');
01337         /*! wenn fehler beim lesen */
01338         if($fh == false){
01339                 /*! dann error ausgeben */
01340                 $out["errors"] .= "ERROR: File not found -> ".$used["protectiondb"]."<br>";
01341         }else {
01342         /*! datei geeofnet , solange bis datei ende */
01343         while (!feof($fh)){
01344                 /*! zeile einlesen */
01345                    $line= fgets ($fh);
01346                    /*! auf fehler beim zeile einlesen pruefen */
01347                    if ($line===FALSE) {
01348                         /*! fuer debugging fehler beim zeile lesen ausgeben */
01349                         if ($debugging)  $out["errors"] .= " cant read line <br>";
01350                    } else {
01351                         /*! default objekt protekt daten */
01352                     $protectiondatas = array();
01353                         /*! regexpression fuer pfad */
01354                         $thematchdatas = "|<filepath>(".quotemeta($used["pathnow"]).".*)</filepath><user>(.*)</user><datetime>(.*)</datetime>|";
01355                         /*! pfad aus zeile extrahieren */
01356                         $gotit = preg_match($thematchdatas,$line,$protectiondatas);
01357                         /*! pfad gefunden */
01358                         if ($gotit > 0) {
01359                                 /*! dann protect datas lesen */
01360                                 $protections[]=$protectiondatas;
01361                         }
01362                    };
01363         }
01364         /*! datei schliessen  */
01365     fclose($fh);
01366         }
01367         /*! rueckgabe protekt daten objekt */
01368         return $protections;
01369 }
01370 /*! \brief check last log entry
01371  *
01372  */
01373 function getlogdata(&$dirlist) {
01374         /*! globale variablen festlegen */
01375         global $out;
01376         global $used;
01377         global $FS;
01378         global $debugging;
01379         /*! default log datei daten */
01380         $logfiledata = array();
01381         /*! login datei zum lesen oeffnen  */
01382         $fh = fopen($used["logfilepath"], 'r');
01383         /*! wenn fehler beim lesen */
01384         if($fh == false){
01385                 /*! dann error ausgeben */
01386                 $out["errors"] .= "ERROR: File not found -> ".$used["logfilepath"]."<br>";
01387         }else {
01388         /*! datei geeofnet , solange bis datei ende */
01389         while (!feof($fh)){
01390                 /*! zeile einlesen */
01391                    $line= fgets ($fh);
01392                    /*! auf fehler beim zeile einlesen pruefen */
01393                    if ($line===FALSE) {
01394                         /*! fuer debugging fehler beim zeile lesen ausgeben */
01395                         if ($debugging)  $out["errors"] .= " cant read line <br>";
01396                    } else {
01397                     /*! log file data loeschen */
01398                     $logfiledatas = array();
01399                         /*! regepression fuer log entry data */
01400                         $thematchdatas = "|^<date>(.*)</date><time>(.*)</time><user>(.*)</user><text>(.*)</text><path>(".quotemeta($used["pathnow"]).".*)</path>|";
01401                         /*! log file data extrahieren */
01402                         if(preg_match($thematchdatas,$line,$logfiledatas)) {
01403                                 /*! gefundenen pfad verschluesseln */
01404                                 $md5logname = md5($logfiledatas[5]);
01405                                 /*! daten fuer pfad eintragen */
01406                                 $logfiledata[$md5logname]=$logfiledatas;
01407                         }
01408                    };
01409         }
01410         /*! datei schliessen */
01411     fclose($fh);
01412         }
01413         /*! fuer jeden eintrag in direktory liste */
01414         foreach ($dirlist as &$dlist) {
01415                         /*! fuer jeden logfile eintrag */
01416                         foreach ($logfiledata as $logentry) {
01417                                 /*! wenn  list pfad und log pfad  gleich  */
01418                                 if (md5($dlist["path"]) == md5($logentry[5])) {
01419                                         /*! dann date aus liste */
01420                                         $targetdate = date_parse($dlist["lastlog"]["date"]." ".$dlist["lastlog"]["time"].".0");
01421                                         /*! dann timestamp aus datum von liste */
01422                                         $oldts = mktime($targetdate["hour"], $targetdate["minute"], $targetdate["second"],  $targetdate["month"], $targetdate["day"],$targetdate["year"]);
01423                                         /*! dann date aus log */
01424                                         $targetdate = date_parse($logentry[1]." ".$logentry[2].".0");
01425                                         /*! dann timestamp aus datum von log */
01426                                         $newdts = mktime($targetdate["hour"], $targetdate["minute"], $targetdate["second"],  $targetdate["month"],$targetdate["day"], $targetdate["year"]);
01427                                         /*! wenn beide werte nicht 0 */
01428                                         if ($newdts > 0 and $oldts > 0) {
01429                                                 /*! wenn neues datum groesser altes datum */
01430                                                 if ($newdts > $oldts) {
01431                                                         /*! dann berechne Differenz */
01432                                                         $wasdts = floor(((time()-$newdts) ));
01433                                                         $wasstr = "";
01434                                                         /*! secunden pro minute */
01435                                                         $minutensecunden = 60;
01436                                                         /*! secunden pro stunde */
01437                                                         $stundensecunden = 60*60;
01438                                                         /*! secunden pro tag */
01439                                                         $tagsecunden =  $stundensecunden *24;
01440                                                         /*! rest secunden */
01441                                                         $secundenrest = $wasdts;
01442                                                         /*! lesbare einheiten default */
01443                                                         $tage="";
01444                                                         $stunden="";
01445                                                         $minuten="";
01446                                                         $secunden="";
01447                                                         /*! schalter fuer gefundene differenz */
01448                                                         $highest = true;
01449                                                         /*! wenn rest groesser tag und noch nichts gefunden */
01450                                                         if ($secundenrest > $tagsecunden AND $highest ) {
01451                                                         /*! dann berechne tage */
01452                                                         $tage = floor($secundenrest/$tagsecunden);
01453                                                             /*! tage string ausgabe */
01454                                                                 $wasstr.=$tage." Tag ";
01455                                                         /*! rest secunden berechnen */
01456                                                         $secundenrest = $secundenrest -($tage*$tagsecunden);
01457                                                         /*! wert wurde gefunden */
01458                                                         $highest = false;
01459                                                         }
01460                                                         /*! wenn rest groesser studnen und noch nichts gefunden */
01461                                                         if ($secundenrest > $stundensecunden AND $highest ) {
01462                                                         /*! dann berechne stunden */
01463                                                         $stunden = floor($secundenrest /$stundensecunden);
01464                                                         /*! stunden string ausgabe */
01465                                                                 $wasstr.=$stunden." Std ";
01466                                                         /*! rest secunden berechnen */
01467                                                         $secundenrest =  $secundenrest-($stundensecunden * $stunden);
01468                                                         /*! wert wurde gefunden */
01469                                                         $highest = false;
01470                                                         }
01471                                                         if ($secundenrest > $minutensecunden AND $highest ) {
01472                                                         $minuten = floor($secundenrest /$minutensecunden);
01473                                                         /*! minuten string ausgabe */
01474                                                                 $wasstr.=$minuten." Min ";
01475                                                         /*! rest secunden berechnen */
01476                                                         $secundenrest =  $secundenrest-($minutensecunden * $minuten);
01477                                                         /*! wert wurde gefunden */
01478                                                         $highest = false;
01479                                                         }
01480                                                         if ($highest ) {
01481                                                                 /*! rest secunden festhalten */
01482                                                                 $secunden = $secundenrest;
01483                                                                 /*! secunden string ausgabe */
01484                                                                         $wasstr.=$secunden." Sek ";
01485                                                                 /*! wert wurde gefunden */
01486                                                                 $highest = false;
01487                                                         }
01488                                                         /*! wenn wert vorhanden dann zeitpsannen wort vor setzen */
01489                                                         if (!$highest) {$wasstr="vor ".$wasstr;}
01490                                                         /*! last log entry setzen augabe string */
01491                                                         $dlist["lastlog"]["entry"] = $wasstr;
01492                                                         /*! last log datum setzen  */
01493                                                         $dlist["lastlog"]["date"] = $logentry[1];
01494                                                         /*! last log zeit setzen  */
01495                                                         $dlist["lastlog"]["time"] = $logentry[2];
01496                                                         /*! last log user setzen  */
01497                                                         $dlist["lastlog"]["user"] = $logentry[3];
01498                                                         /*! last log aktion setzen  */
01499                                                         $dlist["lastlog"]["action"] = $logentry[4];
01500                                                 }
01501                                         }
01502                                 }
01503                         }
01504         }
01505 }
01506 /*! \brief add the protected file to the dbfile
01507  *      \param $filetoprotect Datei Pfad
01508  */
01509 function protectFile($filetoprotect) {
01510         /*! globale variablen festlegen */
01511         global $out;
01512         global $used;
01513         global $FS;
01514         global $debugging;
01515         /*! datei zum anhaengen oeffnen */
01516     if (!$fh = fopen($used["protectiondb"], 'a')) {
01517                 /*! error ausgabe das öffnen der datenbank datei zum daten anhängen ist fehlgeschlagen */
01518         $out["errors"] .= "Cannot open db file to append stuff  <br>";
01519     } else {
01520                 /*! datei ist geoeffnet , also pfad tag erzeugen */
01521                 $thefilepathtag = "<filepath>".$filetoprotect."</filepath>";
01522                 /*! user namen tag erzeugen */
01523                 $theusertag ="<user>".$used["username"]."</user>";
01524                 /*! date time tag erzeugen */
01525                 $thedatetimetag ="<datetime>".date("Y-m-d H:i:s")."</datetime>";
01526                 /*! tags zusammen setzen */
01527                 $taggedline = $thefilepathtag.$theusertag.$thedatetimetag;
01528                 /*! tagzeile zum schreiben ergaenzen */
01529                 $protectionline = $taggedline."\n";
01530                 /*! zeile in datei schreiben */
01531                 if (fwrite($fh, $protectionline) === FALSE) {
01532                         /*! error ausgabe kann datenbank datei keine daten anhängen */
01533                         $out["errors"] .= "Cannot write to db file to append stuff <br>";
01534                 } else {
01535                         /*! erfolgreiches schreiben loggen */
01536                         logThis("file protected",$filetoprotect);
01537                 }
01538                 /*! datei schliessen */
01539                 fclose($fh);
01540         }
01541 }
01542 /*! \brief download work
01543  *      \param $name Pfad der download Datei
01544  *      \param $filename Name der download Datei
01545  */
01546 function downloading($name,     $filename) {
01547                 /*! datei oeffnen zum lesen binar */
01548                 $fh = fopen($name, 'rb');
01549                 /*! wenn fehler beim lesen */
01550                 if($fh == false){
01551                         /*! dann error ausgeben */
01552         $out["errors"] .= "ERROR: File not found -> ".$used["userlogindb"]."<br>";
01553         }else {
01554                 /*! kein fehler also header senden */
01555                 header("Cache-Control: ");// leave blank to avoid IE errors
01556                 header("Pragma: ");// leave blank to avoid IE errors
01557                 header("Content-type: application/octet-stream");
01558                 header("Content-Disposition: attachment; filename=\"" . $filename . "\"");
01559                 header("Content-length:".(string)(filesize($name)));
01560                 /*! warten damit datei im speicher */
01561                 sleep(1);
01562                 /*! chache senden vorbereiten */
01563                 ob_flush();
01564                 /*! cache ausgeben */
01565                 flush();
01566                 /*! solange kein datei ende */
01567                 while(!feof($fh)) {
01568                         /*! block lesen */
01569                    $buffer = fread($fh, 2048);
01570                    /*! und ausgeben */
01571                    print $buffer;
01572                 }
01573                 /*! datei schliessen */
01574                 fclose ($fh);
01575         }
01576 }
01577 /*! \brief download userlog
01578  *
01579  */
01580  function downloaduserLog() {
01581         /*! globale variablen festlegen */
01582         global  $used;
01583         /*! log file name */
01584         $filename = $used["logfile"];
01585         /*! log file pfad */
01586         $name = $used["logfilepath"];
01587         /*! daownload starten */
01588         downloading($name,      $filename);
01589         /*! programm ende , daten wurden schon gesendet */
01590         exit;
01591  }
01592 /*! \brief download file
01593  *      \param $filename Name der download Datei
01594  */
01595 function downloadFile($filename) {
01596         /*! globale variablen festlegen */
01597         global $out;
01598         global $used;
01599         global $FS;
01600         global $debugging;
01601         /*! datei absoluten pfad erzeugen */
01602         $name = $used["pathnow"].$filename;
01603         /*! arbeits variablen default */
01604         $isuser=false;
01605         $isprotected =false;
01606         /*! protektion Daten Objekt fuer pfad lesen */
01607         $protectdata=checkprotection($name,true);
01608         /*! wenn protekt status wahr und protekt name gleich username */
01609         if ($protectdata["status"] AND $protectdata["username"] == $used["username"]) {
01610                 /*! dann downloade pfad */
01611                 downloading($name,      $filename);
01612                 /*! logging vom download */
01613                 logThis("downloaded file",$name);
01614                 /*! programm ende , daten wurden schon gesendet */
01615                 exit;
01616         } else {
01617                 /*! error ausgabe kann nicht downgeloaded werden da ungeschützt */
01618                 $out["errors"] .= "cant download file, you need protect this file <br>";
01619         }
01620 }
01621 /*! \brief path controll
01622  *  \param $path the path to check for injections.
01623  *  \return $newpath the path without injections.
01624  *
01625  *  delete injections in a path , stay in observer folder.
01626  */
01627 function securepath($path) {
01628         /*! arbeit variable default */
01629         $newpath ="";
01630         /*! entfernen von steuer zeichenfolge im pfad */
01631         $newpath = preg_replace("$\.+/$","",$path);
01632         /*! rueckgabe pfad ohne steuer zeichen folge */
01633         return $newpath;
01634 }
01635 ?>