PHP FTPClient

25. března 2004

•

Určitě mnoho z vás má nějaké ty internetové stránky, ať už na freehostingovém nebo placeném serveru. Cestou, jak tyto data spravovat, pokud přímo server nevlastníte, je použití ftp klienta. PHP disponuje základními funkcemi, které slouží pro přístup na souborový systém serveru pomocí webového prohlížeče, takže si ukážeme, jak jich využít.

Prostřednictvím tohoto programu budete schopni provádět následující příkazy:

vytváření adresářů
mazání adresářů
přejmenování adresářů
upload souborů
mazání souborů
přejmenování souborů
stahování souborů
editace souborů
zjišťování informací (typ, velikost, datum poslední modifikace, atributy)

Důležitým aspektem pro správný chod níže popisovaných skriptů je námi požadované nastavení php.ini souboru. Nejsnadnějším způsobem, jak ověřit momentální nastavení, je použití funkce phpinfo(). V první řadě byste měli zajistit podporu FTP funkcí. Pokud se tak stalo, najdete ve výstupu zmíněné funkce řádek FTP support ? enabled. Dále je potřeba mít zapnutou direktivu track_vars a samotnou podporu relací Session Support ? enabled k tomu, abychom mohli využívat pole $_SESSION, $_POST, $_GET, popřípadě $_REQUEST. Ani session, ve které uchováváme uživatelská data, není úplně bezpečná, proto důležité údaje, jako jméno a heslo, budeme šifrovat. Já jsem zde zvolil využití funkcí mcrypt. Pro kontrolu se opětovně podíváme na výstup, kde bychom měli nalézt výpis mcrypt support ? enabled.

Používání registrace globálních proměnných, která je určena direktivou register_globals je nebezpečné, proto je celý program napsán tak, aby tuto direktivu nevyužíval. Co se týče automatického vkládání zpětných lomítek, magic_quotes_gpc, budeme ve skriptech tuto skutečnost kontrolovat a podle toho zařídíme formátování vstupních údajů. Překážkou nejsou ani vypnuté cookies, v takovém případě session id přenášíme v řetězci url.

Vlastní aplikace se bude skládat z následujících souborů a adresářů:

index.php: hlavní soubor, který se stará o vše, mimo editace a odhlášení
editovat.php: skript obsluhující vlastní editaci
functions.inc: soubor s funkcemi
logout.php: odhlášení
rename.php: soubor obsahující formulář pro přejmenování
CSS/style.css: zdroj kaskádových stylů
SCRIPTS/scripts.js: úložiště funkcí javascriptu
ICONS: složka s obrázky
USER_FILES: adresář sloužící k uchování dočasných uživatelských souborů

Dříve než se pustíme do vlastní charakteristiky jednotlivých souborů, respektive skriptů, chtěl bych obecně shrnout, jak celý program vlastně funguje. Po načtení hlavní stránky index.php jsou, pokud jste vyplnili přihlašovací formulář (v případě, že necháte volná políčka se jménem a heslem, jsou jim přiřazeny výchozí hodnoty, tj. anonymous, respektive anon@anon.com), zavolány příslušné přihlašovací funkce. Pokud jsou úspěšné, informujeme uživatele pomocí dočasného textového souboru (session_id().txt), do kterého budeme ukládat všechny zprávy spojené s aktuální relací. Po provedení těchto funkcí je načten zbytek stránky, ve které bude vypsán požadovaný adresář (implicitně „/“). Součástí výpisu budou hypertextové odkazy na další skripty (například pro editaci voláme soubor editace.php).

Všechna data ukládáme pomocí superglobálního pole $_SESSION (nevyužíváme funkce session_register() – alternativní řešení, avšak za cenu snížení bezpečnosti, pro její užívání je potřeba direktivy register_globals). Se session se pojí proměnné jako ftp server, port či již zmíněné zašifrované podoby přihlašovacího jména a hesla.

Soubor style.css

Tento dokument kaskádových stylů nám zaručuje potřebný design aplikace. Na průběh skriptů nemá vliv, ale ani ftp client se neobejde bez použitelného uživatelského rozhraní.

Soubor scripts.js

Ve skriptech budeme využívat tento externí zdroj funkcí JavaScriptu, například pro interaktivní změnu barvy řádků tabulek nebo určení vlastností popUp okna.

Soubor index.php

Jak jsem již výše poznamenal, tento soubor je hlavní skript aplikace, tudíž se stará skoro o vše, mimo editace a odhlášení.

<?php
header(„Cache-Control: no-cache, must-revalidate“);
header(„Pragma: no-cache“);
header(„Expires: 0“);
session_start();
…

V samém začátku souboru odesíláme http hlavičky a inicializujeme vlastní session. Tímto si zajistíme, že skript nebude ukládán do cache. Odeslané informace jsou samozřejmě srozumitelné jak pro http 1.0 header("Pragma: no-cache"), tak i pro verzi 1.1.

…
@include(„functions.inc“);
if (!defined(„INCLUDE“)) {
echo(„<script language=’javascript‘ type=’text/javascript‘>“ .
“ alert(‚Omlouváme se, ale došlo k interní chybě.‘);“ .
„</script>“);
@unlink(„USER_FILES/“.session_id().“.txt“);
$_SESSION = array();
session_destroy();
exit();
}
…

Ačkoli je to ústřední skript, bez funkcí by se neobešel. Konstantou INCLUDE, která je definována v souboru s funkcemi, kontrolujeme úspěšnost, respektive neúspěch příkazu include. Funkce jsou nezbytné pro vlastní chod aplikace, proto v případě selhání informujeme uživatele a ukončíme aktuální session. Součástí tohoto opatření je taktéž vymazání uživatelova dočasného souboru – unlink("USER_FILES/".session_id().".txt").

…
if ($_SESSION[‚ip‘] == „“){
$_SESSION[‚ip‘] = $_ENV[‚REMOTE_ADDR‘];
} else {
if ($_SESSION[‚ip‘] != $_ENV[‚REMOTE_ADDR‘]) konec(„Vaše ip adresa se neshoduje s ip adresou zakladatele aktuální relace!“);
}
if ($_SESSION[‚cesta‘] == „“) $_SESSION[‚cesta‘] = „/“;
if ($_POST[‚prihlaseni‘]) prihlaseni();
…

Pokud je proměnná $_SESSION[‚cesta‘] prázdná, přiřadíme jí výchozí hodnotu, a v případě, že uživatel odeslal přihlašovací formulář, voláme příslušnou funkci prihlaseni(). Také kontrolujeme ip adresu uživatele aktuální relace.

…
if ((isset($_SESSION[‚ftpserver‘])) and (isset($_SESSION[‚port‘]))){
$_SESSION[‚jmeno‘] = trim(@mcrypt_cbc(MCRYPT_XTEA, „ “, html_entity_decode($_SESSION[‚jmeno‘]), MCRYPT_DECRYPT));
$_SESSION[‚heslo‘] = trim(@mcrypt_cbc(MCRYPT_XTEA, „ “, html_entity_decode($_SESSION[‚heslo‘]), MCRYPT_DECRYPT));
if ($_SESSION[‚ssl‘]){
  $_SESSION[‚spojeni‘] = @ftp_ssl_connect($_SESSION[‚ftpserver‘], $_SESSION[‚port‘]);
} else {
  $_SESSION[‚spojeni‘] = @ftp_connect($_SESSION[‚ftpserver‘], $_SESSION[‚port‘]);
}
if (!$_SESSION[‚spojeni‘]){
  uloz_zpravu(sprintf(„Nepodařilo se navázat spojení se serverem %s (port %d)“, $_SESSION[‚ftpserver‘], $_SESSION[‚port‘]));
  $_SESSION = array();
  header(„Location: index.php?“ . SID);
  exit();
}
if (($_SESSION[‚jmeno‘] == „“) and ($_SESSION[‚heslo‘] == „“)){
  $_SESSION[‚jmeno‘] = „anonymous“;
  $_SESSION[‚heslo‘] = „anon@anon.com“;
}
$_SESSION[‚prihlaseni‘] = @ftp_login($_SESSION[‚spojeni‘], $_SESSION[‚jmeno‘], $_SESSION[‚heslo‘]);
if (!$_SESSION[‚prihlaseni‘]){
  uloz_zpravu(sprintf(„Nepodařilo se přihlásit k serveru %s (port %d)“, $_SESSION[‚ftpserver‘], $_SESSION[‚port‘]));
  $_SESSION = array();
  header(„Location: index.php?“ . SID);
  exit();
}
if (($_SESSION[‚jmeno‘] == „anonymous“) and ($_SESSION[‚heslo‘] == „anon@anon.com“)){
  $_SESSION[‚jmeno‘] = „“;
  $_SESSION[‚heslo‘] = „“;
}
$_SESSION[‚jmeno‘] = htmlentities(@mcrypt_cbc(MCRYPT_XTEA, „ “, $_SESSION[‚jmeno‘], MCRYPT_ENCRYPT));
$_SESSION[‚heslo‘] = htmlentities(@mcrypt_cbc(MCRYPT_XTEA, „ “, $_SESSION[‚heslo‘], MCRYPT_ENCRYPT));
if ($_POST[‚prihlaseni‘]){
  uloz_zpravu(sprintf(„Připojení k serveru %s (port %d) bylo úspěšné“, $_SESSION[‚ftpserver‘], $_SESSION[‚port‘]));
}
}
…

Po výše popsaných příkazech se dostáváme k samotnému přihlášení. Pokud je splněn úvodní požadavek, tedy jsou známy hodnoty ftp serveru a portu, dekódujeme proměnné $_SESSION[‚jmeno‘] a $_SESSION[‚heslo‘]. Co se týče vlastního šifrování, zvolil jsem funkci mcrypt v režimu cbc za použití šifrovacího algoritmu MCRYPT_XTEA. Existuje celá škála algoritmů, takže je jen na vás, který si vyberete. Můžete zvolit režim, jehož definice může nabírat hodnot: ecb, cbc, cfb, ofb, nofb a stream.

Dále ověřujeme proměnnou $_SESSION[‚ssl‘]. Pokud je kladná (true), voláme bezpečné připojení, $_SESSION['spojeni'] = @ftp_ssl_connect($_SESSION['ftpserver'], $_SESSION['port']), v opačném případě normální příkaz ftp_connect() (k užívání chráněného přenosu dat, tzn. ssl, je požadována dynamická knihovna OpenSSL, což znamená, že ne všechny servery touto možností disponují). Pokud připojení selže, uložíme zprávu do dočasného souboru, uloz_zpravu(sprintf("Nepodařilo se navázat spojení se serverem %s (port %d)", $_SESSION['ftpserver'], $_SESSION['port'])), vyprázdníme session a zavoláme opětovně stránku index.php. V případě úspěchu se znovu celý proces opakuje, ale s tím rozdílem, že namísto funkce ftp_connect() voláme funkci ftp_login(). Celé přihlášení je na závěr ukončeno opětovným zašifrováním dat.

…
if ($_REQUEST[‚akce‘]){
switch($_REQUEST[‚akce‘]){
  case „nova_slozka“:
   $proved_f = „nova_slozka“;
  break;
  case „upload“:
   $proved_f = „upload“;
  break;
  case „download“:
   $proved_f = „download“;
  break;
  case „smazat“:
   $proved_f = „smazat“;
  break;
  case „file_rename“:
   $proved_f = „file_rename“;
  break;
  case „cesta_pridej“:
   $proved_f = „cesta_pridej“;
  break;
  case „cesta_uber“:
   $proved_f = „cesta_uber“;
  break;
}
$proved_f();
}
…

Dalším krokem, který skript vykonává, je ověření hodnoty proměnné $akce – používáme zde superglobálního pole $_REQUEST, abychom zajistili podporu zdrojů $_POST a $_GET. Hodnoty této proměnné určují názvy funkcí, které se mají provést. Po přiřazení provedeme příslušnou funkci příkazem $proved_f().

…
if ($_SESSION[‚prihlaseni‘]) analyza_adr();
…
$_SESSION[‚velikost_log_file‘] = @filesize(„USER_FILES/“.session_id().“.txt“);
if ($_SESSION[‚velikost_log_file‘] != 0){
$_SESSION[‚log_file‘] = @fopen(„USER_FILES/“.session_id().“.txt“, „r“);
if ($_SESSION[‚log_file‘]){
fpassthru($_SESSION[‚log_file‘]);
} else {
echo(„Otevření zdroje chybových hlášek selhalo“);
}
} else {
echo(„Byla Vám založena nová relace, pro ukončení se prosím odhlaste“);
}
unset($_SESSION[‚log_file‘]);
unset($_SESSION[‚velikost_log_file‘]);
@unlink(„USER_FILES/“.session_id().“.inc“);
?>

A konečně se dostáváme k samotnému výpisu aktuálního adresáře, jenž je určen funkcí analyza_adr(). Zbývající kód obstarává získání informací z našeho dočasného souboru. Pokud neexistuje, pravděpodobně to znamená, že uživatel inicializoval novou relaci, a proto vypíšeme úvodní zprávu. Odstranění souboru unlink("USER_FILES/".session_id().".inc") souvisí s editací, kterou popíši níže.

Soubor logout.php

Po zavolání této stránky dochází k absolutní deaktivaci momentální session a odstranění dočasného textového souboru. Soubor také obsahuje odkaz na hlavní stránku, v případě, že by se uživatel chtěl opět přihlásit.

<?php
header(„Cache-Control: no-cache, must-revalidate“);
header(„Pragma: no-cache“);
header(„Expires: 0“);
session_start();
@unlink(„USER_FILES/“.session_id().“.txt“);
if ($_SESSION[‚spojeni‘]) ftp_close($_SESSION[‚spojeni‘]);
$_SESSION = array();
session_destroy();
?>
…

Soubor functions.inc

Tento soubor obsahuje téměř všechny funkce, které aplikace požaduje.

define(„INCLUDE“, „Příkaz include se provedl úspěšně.“);
if (get_magic_quotes_gpc()) $kontrola_gpc = true;

V úvodu definujeme již zmíněnou konstantu INCLUDE a zjišťujeme, zda server používá automatické vkládání zpětných lomítek. Tuto skutečnost nám reprezentuje proměnná $kontrola_gpc.

První funkcí je funkce uloz_zpravu(), která nám zajišťuje ukládání zpráv pro uživatele aktuální session. Výsledný text, ve formátu [hh:mm dd.MM.YYYY] – zpráva, bude uložen do dočasného souboru, jehož maximální velikost je dána limitem 15 kB.

function zavrit($zprava){
echo(„<script language=’javascript‘ type=’text/javascript‘>“ .
„alert(‚$zprava‘);window.close();“ .
„</script>“);
}

Pomocná funkce zavrit() je spojena s editací souboru a slouží k informování uživatele.

Funkce prihlaseni(), ačkoli název by tomu napovídal, se nestará o vlastní připojení, ale pouze o formátování a kontrolu vstupních dat. V případě, že nejsou zadány hodnoty proměnným $_POST[‚ftpserver‘] a $_POST[‚port‘], je uživatel odkázán zpět na hlavní stranu, pokud jsou, provede se přiřazení hodnot proměnným session a následné šifrování.

Tato funkce je určena k vytváření složek na ftp serveru. Přijímá název složky pomocí pole $_POST a ověřuje, zda je název v pořádku. Pokud ne, je uložena chybová hláška a znovu načteme hlavní stránku. V opačném případě se pokusíme adresář vytvořit funkcí ftp_mkdir().

Tato část kódu se stará o uploadování souborů. Poté, co přiřadíme hodnoty pole $_FILES poli $_SESSION, kontrolujeme důvěryhodnost původu, is_uploaded_file(), a potřebné místo k uložení souboru. Funkce ftp_alloc() je volitelná, použijte ji v případě, že váš server požaduje prealokaci. Po úspěšném zjištění dostatečného místa přecházíme k vlastnímu nahrání souboru. Uložení nám zajišťuje funkce ftp_put(). Ať už některá funkce selže či ne, v obou případech voláme funkci uloz_zpravu(), abychom dali vědět uživateli.

Stažení souboru, jak název napovídá, nám poskytuje funkce download(). Protože jméno požadovaného souboru přenášíme v řetězci URL, musíme si ho, i když to není zcela jistě nejlepší způsob, vytáhnout ze superglobálního pole $_GET. Následně vlastní název zprostíme nepožadovaných znaků, a to tak, že voláme funkci strtr(), které jsme předtím předali argument $preloz. Po úspěšném či neúspěšném stažení souboru opět informujeme uživatele.

Funkce starající se o přiřazení ikonky k názvu souboru dle jeho typu. K tomu, abychom typ poznali, je určena funkce pathinfo(), respektive $_SESSION[‚vystup_typu‘][‚extension‘]. Předem definovaným polem $typ procházíme pomocí cyklu for() a kontrolujeme, zda typ souboru, předaný parametrem $zdali, se neshoduje s jedním z našich daných typů. Pokud ano, je vypsána příslušná ikonka, jinak zobrazíme neznámý typ.

Tento kód obstarává mazání adresářů a souborů. Podle toho, jestli se jedná o soubor nebo složku (což je určeno proměnnou $_POST[‚smazat_dir‘], která byla předána předcházejícím formulářem), použijeme funkci ftp_delete() nebo ftp_rmdir(). Po provedení odešleme kontrolní zprávu.

Z formuláře stránky rename.php přebíráme výchozí název, respektive typ předešlého souboru, a také požadované nové pojmenování. Po odstranění nechtěných znaků „rozložíme“ původní název na dvě části, a to na vlastní název a typ. O to se postará funkce pathinfo(). Poté přistoupíme k samotnému přejmenování, což nám zajistí příkaz ftp_rename(). Na závěr bych chtěl podotknout, že skript běží v novém okně, které slouží pouze pro vstupní formulář, a proto neodesíláme jako obvykle hlavičku s přesměrováním, ale použijeme námi připravenou funkci zavrit(), která vypíše obsah předaný argumentem a okno zavře.

function prepis_mesice($ang){
$preloz = array(„Jan“ => „Led „, „Feb“ => „Úno „, „Mar“ => „Bře „, „Apr“ => „Dub „, „May“ => „Kvě „, „Jun“ => „Čer „, „Jul“ => „Červ „, „Aug“ => „Srp „, „Sep“ => „Zář „, „Oct“ => „Říj „, „Nov“ => „Lis „, „Dec“ => „Pro „);
$mesic_cz = strtr($ang, $preloz);
echo($mesic_cz);
}

Součástí výpisu adresáře je také datum poslední modifikace, a protože je anglicky, přeložíme ho pomocí této funkce.

Pokud uživatel klikne na název adresáře, tato funkce se postará, aby byla složka při příštím volání funkce ftp_rawlist() vypsána. V případě, že se proměnná $_SESSION[‚cesta‘] nerovná výchozímu znaku, přiřadíme název nového adresáře nakonec, jinak se rovná přímo novému názvu.

function cesta_uber(){
$_SESSION[‚cesta‘] = explode(„/“, $_SESSION[‚cesta‘]);
$_SESSION[‚posledni_index‘] = (count($_SESSION[‚cesta‘]) – 1);
unset($_SESSION[‚cesta‘][$_SESSION[‚posledni_index‘]]);
unset($_SESSION[‚posledni_index‘]);
$_SESSION[‚cesta‘] = implode(„/“, $_SESSION[‚cesta‘]);
}

Tento skript je protipólem funkce cesta_pridej(), starající se o vypsání nadřazeného adresáře. K tomu, aby byl vždy vypsán ten adresář, který požadujeme, zavoláme funkci explode() a vymažeme část posledního indexu. Následně dáme vše opět dohromady a přiřadíme výstup proměnné.

Funkce editace() je volána uvnitř funkce analyza_adr() a kontroluje, zda soubor předaný parametrem $zjisti je vhodným zdrojem k editaci. Proměnná $ret_typu tvoří vlastní seznam povolených typů, tedy textových souborů.

A konečně se dostáváme k hlavní funkci analyza_adr(), která nám poslouží k výtahu chtěných informací z funkce ftp_rawlist(). Neformátovaný výstup předešlé funkce přiřadíme proměnné $_SESSION[‚vypis_adresare‘], se kterou budeme dále pracovat. Prvním filtrem, kterým data projdou, budou regulární výrazy, respektive funkce eregi(). Protože generovaná data jsou uspořádána do pole, tak jak jim odpovídají jednotlivé řádky ve tvaru jako drwxrwxr-x 5 user group 1258 Feb 12 12:26 my_dir, použijeme před voláním zmíněné funkce určitý způsob, jak tímto polem procházet. Já jsem zde zvolil programátorům známý konstrukt foreach(). Sítem ve tvaru regulárních výrazů nám bude syntaxe eregi("^([bcdlsp-][rwxts-]{9}).*[ \f\r\t\n]([0-9]*)[ \f\r\t\n]([a-z]{3})[ \f\r\t\n]([0-9]{1,2}[ \f\r\t\n][0-9]{1,2}:[0-9]{1,2})[ \f\r\t\n] (.+)$", $_SESSION['raw'], $_SESSION['part']).

Cílem naší práce jsou závorkami uzavřené výrazy, které budou dočasně uschovány v poli $_SESSION[‚part‘]. To znamená, že každý výraz bude odpovídat své hodnotě, a to tak, že:

$_SESSION[‚part‘][1] – atributy souboru či složky
$_SESSION[‚part‘][2] – velikost souboru v byte
$_SESSION[‚part‘][3] – anglický název měsíce
$_SESSION[‚part‘][4] – datum (den, hodina, minuta) poslední změny
$_SESSION[‚part‘][5] – název složky či souboru

Po vykonání výše uvedených příkazů kontrolujeme, zda se jedná o soubor nebo složku. Určení typu není nijak složité, postačí nám pouhá kontrola počátečního znaku. Písmeno „d“ znamená adresář, pomlčka soubor. Zbývající kód funkce je tvořen převážně elementy HTML, vyjma úpravy velikosti a funkce print(), a je určen k uspořádání získaných informací.

Soubor editovat.php

Tento soubor slouží k editaci souborů a voláme ho v případě, že soubor, který chceme editovat, je textového typu.

…
$_SESSION[‚file_to_edit‘] = urldecode($_GET[‚editovat‘]);
if ($kontrola_gpc){
$_SESSION[‚file_to_edit‘] = stripslashes($_SESSION[‚file_to_edit‘]);
}
$preloz = array(„\\“ => „“, „/“ => „“, „:“ => „“, „*“ => „“, „?“ => „“, „\““ => „“, „<“ => „“, „>“ => „“, „|“ => „“);
$_SESSION[‚file_to_edit‘] = strtr($_SESSION[‚file_to_edit‘], $preloz);
$_SESSION[‚edit_docasne‘] = @fopen(„USER_FILES/“.session_id().“.inc“, „w“);
if (!$_SESSION[‚edit_docasne‘]){
uloz_zpravu(sprintf(„Během stahování souboru %s došlo k chybě“, $_SESSION[‚file_to_edit‘]));
@unlink(„USER_FILES/“.session_id().“.inc“);
unset($_SESSION[‚file_to_edit‘]);
unset($_SESSION[‚edit_docasne‘]);
zavrit(‚Pro ověření úspěšnosti editace aktualizujte prosím následující stránku pomocí nadřazeného adresáře (..).‘);
exit();
}
if (!(@ftp_fget($_SESSION[‚spojeni‘], $_SESSION[‚edit_docasne‘], $_SESSION[‚cesta‘] . „/“ . $_SESSION[‚file_to_edit‘], FTP_ASCII))){
uloz_zpravu(sprintf(„Během stahování souboru %s došlo k chybě“, $_SESSION[‚file_to_edit‘]));
fclose($_SESSION[‚edit_docasne‘]);
@unlink(„USER_FILES/“.session_id().“.inc“);
unset($_SESSION[‚file_to_edit‘]);
unset($_SESSION[‚edit_docasne‘]);
zavrit(‚Pro ověření úspěšnosti editace aktualizujte prosím následující stránku pomocí nadřazeného adresáře (..).‘);
exit();
}
fclose($_SESSION[‚edit_docasne‘]);
$_SESSION[‚edit_docasne‘] = @fopen(„USER_FILES/“.session_id().“.inc“, „r“);
if (!$_SESSION[‚edit_docasne‘]){
uloz_zpravu(sprintf(‚Během stahování souboru %s došlo k chybě‘, $_SESSION[‚file_to_edit‘]));
@unlink(„USER_FILES/“.session_id().“.inc“);
unset($_SESSION[‚obsah_doc_souboru‘]);
unset($_SESSION[‚puvodni_nazev‘]);
unset($_SESSION[‚edit_docasne‘]);
zavrit(‚Pro ověření úspěšnosti editace aktualizujte prosím následující stránku pomocí nadřazeného adresáře (..).‘);
exit();
}
…
fpassthru($_SESSION[‚edit_docasne‘]);
@unlink(„USER_FILES/“.session_id().“.inc“);
unset($_SESSION[‚file_to_edit‘]);
unset($_SESSION[‚edit_docasne‘]);
…

Název souboru k editaci získáme z pole $_GET a přiřadíme ho session proměnné $_SESSION[‚file_to_edit‘]. Poté se pokusíme vytvořit dočasný soubor, $_SESSION['edit_docasne'] = @fopen("USER_FILES/".session_id().".inc", "w"), do něhož uložíme obsah námi požadovaného souboru. Vlastní načtení provedeme příkazem ftp_fget(), a to v režimu „ASCII“, který je vhodný pro práci s textem. V případě úspěchu otevřeme námi vytvořený dočasný soubor a získáme z něj obsažené informace, které v zápětí vypíšeme pomocí fpassthru().

if ($_POST[‚nahrej_zpet‘]){
$_SESSION[‚puvodni_nazev‘] = $_POST[‚puvodni_nazev‘];
$_SESSION[‚obsah_doc_souboru‘] = $_POST[‚obsah_doc_souboru‘];
if ($kontrola_gpc){
  $_SESSION[‚puvodni_nazev‘] = stripslashes($_SESSION[‚puvodni_nazev‘]);
  $_SESSION[‚obsah_doc_souboru‘] = stripslashes($_SESSION[‚obsah_doc_souboru‘]);
}
$_SESSION[‚edit_docasne‘] = @fopen(„USER_FILES/“.session_id().“.inc“, „w+“);
if ($_SESSION[‚edit_docasne‘]){
  fwrite($_SESSION[‚edit_docasne‘], $_SESSION[‚obsah_doc_souboru‘]);
} else {
  uloz_zpravu(sprintf(„Během uploadování souboru %s došlo k chybě“, $_SESSION[‚puvodni_nazev‘]));
  @unlink(„USER_FILES/“.session_id().“.inc“);
  unset($_SESSION[‚obsah_doc_souboru‘]);
  unset($_SESSION[‚puvodni_nazev‘]);
  unset($_SESSION[‚edit_docasne‘]);
  zavrit(‚Pro ověření úspěšnosti editace aktualizujte prosím následující stránku pomocí nadřazeného adresáře (..).‘);
  exit();
}
rewind($_SESSION[‚edit_docasne‘]);
if (!(@ftp_fput($_SESSION[‚spojeni‘], $_SESSION[‚cesta‘] . „/“ . $_SESSION[‚puvodni_nazev‘], $_SESSION[‚edit_docasne‘], FTP_ASCII))){
  uloz_zpravu(sprintf(„Během uploadování souboru %s došlo k chybě“, $_SESSION[‚puvodni_nazev‘]));
  fclose($_SESSION[‚edit_docasne‘]);
  @unlink(„USER_FILES/“.session_id().“.inc“);
  unset($_SESSION[‚obsah_doc_souboru‘]);
  unset($_SESSION[‚puvodni_nazev‘]);
  unset($_SESSION[‚edit_docasne‘]);
  zavrit(‚Pro ověření úspěšnosti editace aktualizujte prosím následující stránku pomocí nadřazeného adresáře (..).‘);
  exit();
}
uloz_zpravu(sprintf(„Soubor %s byl úspěšně editován“, $_SESSION[‚puvodni_nazev‘]));
fclose($_SESSION[‚edit_docasne‘]);
@unlink(„USER_FILES/“.session_id().“.inc“);
unset($_SESSION[‚obsah_doc_souboru‘]);
unset($_SESSION[‚puvodni_nazev‘]);
unset($_SESSION[‚edit_docasne‘]);
zavrit(‚Pro ověření úspěšnosti editace aktualizujte prosím následující stránku pomocí nadřazeného adresáře (..).‘);
exit();
}

Toto je velmi podobné výše uvedené části kódu pouze s tím rozdílem, že z formuláře získáváme původní název editovaného souboru a jeho obsah, který posléze zapíšeme do nám již známého dočasného souboru a pokusíme se ho uložit pod zmíněným názvem na ftp server. Samotné nahrání vykonáme příkazem ftp_fput().

Kompletní zdrojové soubory si můžete stáhnout a použít ve vlastních aplikacích.