9. Funkcje sieciowe PHP
Przechodzimy teraz do funkcji sieciowych PHP, które umożliwiają nam programowanie w protokołach TCP / IP (Transfer Control Protocol / Internet Protocol).
9.1. Pobieranie nazwy lub adresu IP komputera w Internecie (inet_01)
<?php
// funkcje: nazwa maszyny <--> adres maszyny IP
ini_set("display_errors", "off");
// stałe
$HOTES = array("istia.univ-angers.fr", "www.univ-angers.fr", "www.ibm.com", "localhost", "", "xx");
// adresy IP maszyn z $HOTES
for ($i = 0; $i < count($HOTES); $i++) {
getIPandName($HOTES[$i]);
}
// koniec
exit;
//------------------------------------------------
function getIPandName($nomMachine) {
//$nomMachine: nazwa maszyny, której adres IP chcemy uzyskać
// nomMachine-->adres IP
$ip = gethostbyname($nomMachine);
if ($ip != $nomMachine) {
print "ip[$nomMachine]=$ip\n";
// adres IP --> nomMachine
$name = gethostbyaddr($ip);
if ($name != $ip) {
print "name[$ip]=$name\n";
} else {
print "Erreur, machine[$ip] non trouvée\n";
}
} else {
print "Erreur, machine[$nomMachine] non trouvée\n";
}
}
Wyniki:
ip[istia.univ-angers.fr]=193.49.146.171
name[193.49.146.171]=istia.istia.univ-angers.fr
ip[www.univ-angers.fr]=193.49.144.40
name[193.49.144.40]=ametys-fo.univ-angers.fr
ip[www.ibm.com]=129.42.56.216
Erreur, machine[129.42.56.216] non trouvée
ip[localhost]=127.0.0.1
name[127.0.0.1]=localhost127.0.0.1
ip[]=192.168.1.11
name[192.168.1.11]=st-PC.home
Erreur, machine[xx] non trouvée
Uwagi
- wiersz 4: ustawiono, aby błędy wykonania nie były wyświetlane.
Funkcje sieciowe PHP są wykorzystywane w funkcji getIpandName w wierszu 15.
- wiersz 18: funkcja gethostbyname($nom) pozwala uzyskać adres IP „ip3.ip2.ip1.ip0” komputera o nazwie $nom. Jeśli komputer o nazwie $nom nie istnieje, funkcja zwraca $nom jako wynik.
- wiersz 22: funkcja gethostbyaddr($ip) pozwala uzyskać nazwę komputera o adresie $ip w postaci „ip3.ip2.ip1.ip0”. Jeśli komputer o adresie $ip nie istnieje, funkcja zwraca wynik $ip.
9.2. Klient internetowy ( inet_02)
Skrypt umożliwiający pobranie treści strony głównej serwisu internetowego.
<?php
// obsługa błędów
ini_set("display_errors","off");
// pobieranie tekstu HTML z URL
// lista stron internetowych
$SITES = array("istia.univ-angers.fr", "www.univ-angers.fr", "www.ibm.com", "xx");
// odczyt stron indeksowych witryn z tabeli $SITES
for ($i = 0; $i < count($SITES); $i++) {
// odczyt strony indeksowej serwisu $SITES[$i]
$résultat = getIndex($SITES[$i]);
// wyświetlanie wyniku
print "$résultat\n";
}//dla
// koniec
exit;
//-----------------------------------------------------------------------
function getIndex($site) {
// odczytuje plik URL $site/ i zapisuje go w pliku $site.html
// utworzenie pliku $site.html
$html = fopen("$site.html", "w");
if (!$html)
return "Erreur lors de la création du fichier $site.html";
// nawiązanie połączenia na porcie 80 serwera $site
$connexion = fsockopen($site, 80);
// powrót w przypadku błędu
if (!$connexion)
return "Echec de la connexion au site ($site,80) : $erreur";
// $connexion reprezentuje dwukierunkowy strumień komunikacji
// między klientem (tym programem) a serwerem WWW, z którym nawiązano połączenie
// kanał ten służy do wymiany poleceń i informacji
// protokołem komunikacji jest HTTP
// klient wysyła polecenie GET, aby zażądać pliku URL /
// składnia polecenia GET: URL HTTP/1.0
// nagłówki (headers) protokołu HTTP muszą kończyć się pustym wierszem
fputs($connexion, "GET / HTTP/1.0\n\n");
// serwer odpowie teraz na kanale $connexion. Wyśle wszystkie
// te dane, a następnie zamknie kanał. Klient odczytuje zatem wszystko, co nadchodzi z $connexion
// aż do zamknięcia kanału
while ($ligne = fgets($connexion, 1000))
fputs($html, $ligne);
// klient z kolei zamyka połączenie
fclose($connexion);
// zamknięcie pliku $html
fclose($html);
// powrót
return "Transfert réussi de la page index du site $site";
}
Wyniki: na przykład plik otrzymany dla witryny [www.ibm.com]:
- wiersze 1–11 to nagłówki HTTP z odpowiedzi serwera
- wiersz 1: serwer prosi klienta o przekierowanie do adresu wskazanego w wierszu 8
- wiersz 2: data i godzina odpowiedzi
- wiersz 3: identyfikator serwera WWW
- wiersz 4: treść wysłana przez serwer. W tym przypadku jest to strona HTML, która zaczyna się w wierszu 13
- wiersz 12: pusty wiersz kończący nagłówki HTTP
- wiersze 13–19: strona HTML wysłana przez serwer WWW.
Komentarze do kodu:
- wiersz 7: lista adresów URL stron internetowych, z których chcemy pobrać stronę główną. Zostanie ona zapisana w pliku tekstowym [nomsite.html].
- wiersz 11: zadanie wykonuje funkcja getIndex
- wiersz 19: funkcja getIndex($site) pobiera stronę główną (lub stronę indeksową) serwisu internetowego $site i zapisuje ją w pliku tekstowym $site.html.
- wiersz 27: funkcja fsockopen($site,$port) pozwala na nawiązanie połączenia z usługą TCP / IP działającą na porcie $port na komputerze $site. Po nawiązaniu połączenia klient–serwer wiele usług TCP / IP wymienia wiersze tekstu. Tak jest w przypadku protokołu HTTP (HyperText Transfer Protocol). Strumień danych z serwera docierający do klienta można wówczas traktować jako plik tekstowy. To samo dotyczy strumienia danych wysyłanego z klienta do serwera.
- wiersz 38: funkcja fputs umożliwia klientowi wysyłanie danych do serwera. W tym przypadku wysłany wiersz tekstu ma następujące znaczenie: „Chcę (GET) stronę główną (/) serwisu internetowego, z którym jestem połączony. Korzystam z protokołu HTTP w wersji 1.0”. Aktualna wersja tego protokołu to 1.1.
- wiersz 42: wiersze tekstu zawarte w odpowiedzi serwera można odczytywać po kolei za pomocą pętli while i zapisywać w pliku tekstowym [$site.html]. Gdy serwer WWW wyśle żądaną stronę, zamyka połączenie z klientem. Po stronie klienta zostanie to wykryte jako koniec pliku.
9.3. Klient SMTP (inet_03)
Spośród protokołów TCP / IP, SMTP (SendMail Transfer Protocol) jest protokołem komunikacyjnym usługi wysyłania wiadomości.
Uwagi:
- na komputerze z systemem Windows wyposażonym w program antywirusowy, program ten prawdopodobnie uniemożliwi skryptowi PHP nawiązanie połączenia z portem 25 serwera SMTP. W takim przypadku należy wyłączyć program antywirusowy. Na przykład w przypadku McAfee można postępować w następujący sposób:
 |
- na [1], włącza się konsolę VirusScan
- w przypadku [2] należy zatrzymać usługę [Protection lors de l'accès]
- w przypadku [3] usługa jest zatrzymana
Skrypt:
<?php
// klient SMTP (protokół transferu SendMail) umożliwiający wysłanie wiadomości
// dane są pobierane z pliku $INFOS zawierającego następujące wiersze
// wiersz 1: smtp, nadawca, odbiorca
// kolejne wiersze: treść wiadomości
// nadawca: adres e-mail nadawcy
// odbiorca: adres e-mail odbiorcy
// SMTP: nazwa serwera SMTP, z którego należy korzystać
// protokół komunikacji klient-serwer SMTP
// -> klient łączy się z serwerem SMTP na porcie 25
// <- serwer wysyła mu wiadomość powitalną
// -> klient wysyła polecenie EHLO: nazwa swojego komputera
// <- serwer odpowiada OK lub nie
// -> klient wysyła polecenie mail from: <nadawca>
// <- serwer odpowiada OK lub nie
// -> klient wysyła polecenie rcpt do: <odbiorca>
// <- serwer odpowiada OK lub nie
// -> klient wysyła polecenie „data”
// <- serwer odpowiada OK lub nie
// -> klient wysyła wszystkie wiersze swojej wiadomości i kończy wierszem zawierającym znak
// jedyny znak.
// <- serwer odpowiada OK lub nie
// -> klient wysyła polecenie quit
// <- serwer odpowiada OK lub nie
// odpowiedzi serwera mają postać xxx tekst, gdzie xxx to trzycyfrowa liczba. Każda liczba xxx >=500
// oznacza błąd. Odpowiedź może składać się z kilku wierszy, z których wszystkie oprócz ostatniego zaczynają się od xxx
// w postaci xxx(spacja)
// wymieniane wiersze tekstu muszą kończyć się znakami RC(#13) i LF(#10)
// dane
$INFOS = "mail.txt"; // parametry wysyłania wiadomości
// pobierane są parametry wiadomości
list($erreur, $smtpServer, $expéditeur, $destinataire, $message) = getInfos($INFOS);
// błąd?
if ($erreur) {
print "$erreur\n";
exit;
}
print "Envoi du message [$smtpServer,$expéditeur,$destinataire]\n";
// wysyłanie wiadomości w trybie szczegółowym
$résultat = sendmail($smtpServer, $expéditeur, $destinataire, $message, 1);
print "Résultat de l'envoi : $résultat\n";
// koniec
exit;
//-----------------------------------------------------------------------
function getInfos($fichier) {
// zwraca informacje ($smtp,$expéditeur,$destinataire,$message) z pliku tekstowego $fichier
// wiersz 1: smtp, nadawca, odbiorca
// kolejne wiersze: treść wiadomości
// otwarcie pliku $fichier
$infos = fopen($fichier, "r");
// czy plik $fichier istnieje
if (!$infos)
return array("Le fichier $fichier n'a pu être ouvert en lecture");
// odczyt pierwszego wiersza
$ligne = fgets($infos, 1000);
// usunięcie znaku końca wiersza
$ligne = cutNewLineChar($ligne);
// pobieranie pól smtp, nadawca, odbiorca
$champs = explode(",", $ligne);
// czy liczba pól jest prawidłowa?
if (count($champs) != 3)
return "La ligne 1 du fichier $fichier (serveur smtp, expéditeur, destinataire) a un
nombre de champs incorrect";
// „przetwarzanie” pobranych informacji
for ($i = 0; $i < count($champs); $i++)
$champs[$i] = trim($champs[$i]);
// pobieranie pól
list($smtpServer, $expéditeur, $destinataire) = $champs;
// odczyt wiadomości
$message = "";
while ($ligne = fgets($infos, 1000))
$message.=$ligne;
fclose($infos);
// powrót
return array("", $smtpServer, $expéditeur, $destinataire, $message);
}
//-----------------------------------------------------------------------
function sendmail($smtpServer, $expéditeur, $destinataire, $message, $verbose) {
// wysyła $message na serwer SMTP $smtpserver w imieniu $expéditeur
// dla $destinataire. Jeśli $verbose=1, śledzi wymianę danych między klientem a serwerem
// pobierana jest nazwa klienta
$client = gethostbyaddr(gethostbyname(""));
// nawiązanie połączenia na porcie 25 serwera $smtpServer
$connexion = fsockopen($smtpServer, 25);
// powrót w przypadku błędu
if (!$connexion)
return "Echec de la connexion au site ($smtpServer,25)";
// $connexion reprezentuje dwukierunkowy strumień komunikacji
// między klientem (tym programem) a serwerem SMTP, z którym nawiązano połączenie
// kanał ten służy do wymiany poleceń i informacji
// po nawiązaniu połączenia serwer wysyła wiadomość powitalną, którą odczytujemy
$erreur = sendCommand($connexion, "", $verbose, 1);
if ($erreur) {
fclose($connexion);
return $erreur;
}
// polecenie „ehlo”:
$erreur = sendCommand($connexion, "EHLO $client", $verbose, 1);
if ($erreur) {
fclose($connexion);
return $erreur;
}
// polecenie mail from:
$erreur = sendCommand($connexion, "MAIL FROM: <$expéditeur>", $verbose, 1);
if ($erreur) {
fclose($connexion);
return $erreur;
}
// polecenie rcpt to:
$erreur = sendCommand($connexion, "RCPT TO: <$destinataire>", $verbose, 1);
if ($erreur) {
fclose($connexion);
return $erreur;
}
// polecenie data
$erreur = sendCommand($connexion, "DATA", $verbose, 1);
if ($erreur) {
fclose($connexion);
return $erreur;
}
// przygotowanie wiadomości do wysłania
// musi zawierać następujące wiersze
// From: nadawca
// Do: odbiorca
// pusta linia
// Treść wiadomości
// .
$data = "From: $expéditeur\r\nTo: $destinataire\r\n$message\r\n.\r\n";
$erreur = sendCommand($connexion, $data, $verbose, 0);
if ($erreur) {
fclose($connexion);
return $erreur;
}
// polecenie quit
$erreur = sendCommand($connexion, "QUIT", $verbose, 1);
if ($erreur) {
fclose($connexion);
return $erreur;
}
// koniec
fclose($connexion);
return "Message envoyé";
}
// --------------------------------------------------------------------------
function sendCommand($connexion, $commande, $verbose, $withRCLF) {
// wysyła $commande do kanału $connexion
// tryb szczegółowy, jeśli $verbose=1
// jeśli $withRCLF=1, dodaje sekwencję RCLF do wymiany
// dane
if ($withRCLF)
$RCLF = "\r\n"; else
$RCLF="";
// wysyłanie polecenia, jeśli $commande nie jest puste
if ($commande) {
fputs($connexion, "$commande$RCLF");
// ewentualne echo
if ($verbose)
affiche($commande, 1);
}//if
// odczyt odpowiedzi
$réponse = fgets($connexion, 1000);
// ewentualne echo
if ($verbose)
affiche($réponse, 2);
// odzyskanie kodu błędu
$codeErreur = substr($réponse, 0, 3);
// ostatni wiersz odpowiedzi?
while (substr($réponse, 3, 1) == "-") {
// odczyt odpowiedzi
$réponse = fgets($connexion, 1000);
// ewentualne echo
if ($verbose)
affiche($réponse, 2);
}//while
// odpowiedź zakończona
// błąd zwrócony przez serwer?
if ($codeErreur >= 500)
return substr($réponse, 4);
// powrót bez błędu
return "";
}
// --------------------------------------------------------------------------
function affiche($échange, $sens) {
// wyświetla na ekranie $échange
// jeśli $sens=1, wyświetla -->$echange
// jeśli $sens=2, wyświetla <-- $échange bez dwóch ostatnich znaków RCLF
switch ($sens) {
case 1:
print "--> [$échange]\n";
return;
case 2:
$L = strlen($échange);
print "<-- [" . substr($échange, 0, $L - 2) . "]\n";
return;
}//przełącznik
}
// --------------------------------------------------------------------------
function cutNewLinechar($ligne) {
// usuwa się znak końca linii z $ligne, jeśli istnieje
...
}
Plik infos.txt:
- wiersz 1: [smtp.orange.fr] – serwer używany do wysyłania wiadomości, [serge.tahe@univ-angers.fr] – adres nadawcy, [serge.tahe@istia.univ-angers.fr] – adres odbiorcy
- wiersz 2: nagłówki wiadomości. Tutaj jest tylko jeden – temat wiadomości.
- wiersz 3: pusty wiersz kończy nagłówki wiadomości
- wiersze 4–7: treść wiadomości
Wyniki na ekranie:
- wiersz 1: komunikat śledzący przebieg wykonywania skryptu
- wiersz 2: pierwsza odpowiedź serwera SMTP. Jest to odpowiedź na połączenie klienta z portem 25 serwera SMTP. Odpowiedzi serwera mają postać wierszy o formacie [xxx message] lub [xxx-message]. Pierwsza składnia oznacza, że odpowiedź jest zakończona. xxx to kod wyniku. Wartość większa lub równa 500 oznacza błąd. Druga składnia oznacza, że odpowiedź nie jest zakończona i nastąpi kolejny wiersz.
- wiersz 2: serwer SMTP sygnalizuje, że jest gotowy do przyjmowania poleceń
- wiersz 3: klient wysyła polecenie [EHLO nomDeMachine], gdzie nomDeMachine to nazwa internetowa komputera, na którym działa klient
- wiersze 4–10: odpowiedź serwera SMTP
- wiersz 11: klient wysyła polecenie [MAIL FROM: <expéditeur>], które określa adres e-mail nadawcy.
- wiersz 12: serwer SMTP potwierdza, że akceptuje ten adres. Mógłby go odrzucić, gdyby składnia była nieprawidłowa. Nie sprawdza jednak, czy adres e-mail rzeczywiście istnieje.
- wiersz 13: klient wysyła polecenie [RCPT TO: <destinataire>], które określa adres e-mail odbiorcy wiadomości.
- wiersz 14: serwer SMTP odpowiada, że akceptuje ten adres. Również w tym przypadku przeprowadzana jest weryfikacja składniowa.
- wiersz 15: klient wysyła polecenie [DATA], które informuje użytkownika, że kolejne wiersze stanowią treść wiadomości.
- wiersz 16: serwer odpowiada, że wiadomość może zostać wysłana. Jest to ciąg wierszy tekstu, który musi kończyć się wierszem składającym się z jednego znaku – kropki.
- wiersze 17–25: wiadomość wysłana przez klienta
- wiersze 17–19: nagłówki wiadomości [From:, To:, Subject:] służą do wskazania odpowiednio nadawcy, odbiorcy i tematu wiadomości.
- wiersz 20: pusty wiersz sygnalizujący koniec nagłówków
- wiersze 21–23: treść wiadomości
- wiersz 24: wiersz składający się z pojedynczej kropki, sygnalizujący koniec wiadomości.
- wiersz 26: serwer SMTP odpowiada, że akceptuje wiadomość
- wiersz 27: klient wysyła polecenie [QUIT], aby poinformować o zakończeniu operacji
- wiersz 28: serwer SMTP odpowiada, że zamknie połączenie z klientem
Komentarze do kodu
Nie będziemy szczegółowo omawiać kodu skryptu, ponieważ został on obszernie skomentowany.
- wiersze 48–80: funkcja przetwarzająca plik [infos.txt], zawierający wiadomość do wysłania oraz informacje niezbędne do jej wysłania. Zwraca tablicę ($erreur, $smtpServer, $expéditeur, $destinataire, $messge) zawierającą:
- $erreur: ewentualny komunikat o błędzie, w przeciwnym razie puste.
- $smtpServer: nazwa serwera SMTP, z którym należy się połączyć
- $expéditeur: adres e-mail nadawcy
- $destinataire: adres e-mail odbiorcy
- $message: wiadomość do wysłania. Oprócz treści wiadomości mogą występować nagłówki.
- wiersze 84–157: funkcja sendMail odpowiada za wysłanie wiadomości. Jej parametry są następujące:
- $smtpServer: nazwa serwera SMTP, z którym należy się połączyć
- $expéditeur: adres e-mail nadawcy
- $destinataire: adres e-mail odbiorcy
- $message: treść wiadomości do wysłania.
- $verbose: wartość 1 oznacza, że komunikacja z serwerem SMTP ma być wyświetlana na konsoli.
Funkcja sendMail zwraca komunikat o błędzie; jeśli nie wystąpił żaden błąd, zwraca pusty komunikat.
- wiersz 88: pozwala uzyskać nazwę systemu Windows komputera działającego z funkcją OS.
- linia 99: widzieliśmy, że dialog klient–serwer przebiegał w następujący sposób:
- wysłanie przez klienta polecenia w jednym wierszu
- odpowiedź serwera w jednej lub kilku liniach
- wiersze 161–208: funkcja sendCommand przyjmuje następujące parametry:
- $connexion: kanał TCP / IP łączący klienta z serwerem
- $commande: polecenie, które ma zostać wysłane tym kanałem. Odczytana zostanie odpowiedź serwera na to polecenie.
- $verbose: wartość 1 oznacza, że komunikacja z serwerem SMTP ma być wyświetlana na konsoli.
- $withRCLF: wartość 1 oznacza, że na końcu polecenia należy dodać znak końca linii „\r\n”
- wiersz 173: wysłanie polecenia przez klienta
- wiersz 181: odczyt pierwszego wiersza odpowiedzi serwera SMTP w postaci xxx tekst lub xxx-tekst. Ten ostatni przypadek oznacza, że serwer ma do wysłania kolejny wiersz. xxx to kod błędu wysłany przez serwer.
- wiersz 188 – pobranie kodu błędu z odpowiedzi
- wiersze 191–199: odczyt pozostałych wierszy odpowiedzi
- wiersze 203–204: jeśli kod błędu jest >=500, oznacza to, że serwer SMTP zgłasza błąd.
9.4. Drugi program do wysyłania wiadomości e-mail (inet_04)
Ten skrypt ma taką samą funkcjonalność jak poprzedni: wysyłanie wiadomości e-mail. Wykorzystujemy do tego moduły z biblioteki PEAR. Biblioteka ta zawiera dziesiątki modułów obejmujących różne dziedziny. Wykorzystamy następujące z nich:
- Net/SMTP: moduł umożliwiający komunikację z serwerem SMTP
- Mail: moduł umożliwiający zarządzanie wysyłaniem wiadomości e-mail przy użyciu różnych protokołów.
- Mail/Mime: moduł umożliwiający tworzenie wiadomości, do której można dołączyć dokumenty.
Aby móc korzystać z tych modułów, należy je najpierw zainstalować na komputerze, na którym uruchamiany jest skrypt PHP. Instalacja pakietu oprogramowania WampServer spowodowała zainstalowanie interpretera PHP. W jego drzewie katalogów można zainstalować moduły PEAR.
 |
- w [1], folder instalacyjny interpretera PHP
- w [2], folder PEAR, który będzie zawierał moduły PEAR, które zostaną zainstalowane
- w [3], plik poleceń [go-pear.bat], który inicjuje bibliotekę PEAR
Aby zainicjować bibliotekę PEAR, należy otworzyć okno DOS i uruchomić plik [go-pear.bat]. Skrypt ten połączy się ze stroną internetową biblioteki PEAR. Wymagane jest zatem połączenie z Internetem.
Po połączeniu się ze stroną internetową biblioteki PEAR skrypt pobierze pewną liczbę elementów. Wśród nich znajdzie się nowy skrypt [pear.bat]. To właśnie za pomocą tego skryptu zainstalujemy różne moduły PEAR, których potrzebujemy. Skrypt ten wywołuje się z argumentami. Wśród nich argument [help] pozwala uzyskać listę poleceń obsługiwanych przez skrypt:
C:\serveursSGBD\wamp21\bin\PHP\php5.3.5>pear help
Commands:
build Build an Extension From C Source
bundle Unpacks a Pecl Package
channel-add Add a Channel
channel-alias Specify an alias to a channel name
channel-delete Remove a Channel From the List
channel-discover Initialize a Channel from its server
channel-info Retrieve Information on a Channel
channel-login Connects and authenticates to remote channel server
channel-logout Logs out from the remote channel server
channel-update Update an Existing Channel
clear-cache Clear Web Services Cache
config-create Create a Default configuration file
config-get Show One Setting
config-help Show Information About Setting
config-set Change Setting
config-show Show All Settings
convert Convert a package.xml 1.0 to package.xml 2.0 format
cvsdiff Run a "cvs diff" for all files in a package
cvstag Set CVS Release Tag
download Download Package
download-all Downloads each available package from the default channel
info Display information about a package
install Install Package
list List Installed Packages In The Default Channel
list-all List All Packages
list-channels List Available Channels
list-files List Files In Installed Package
list-upgrades List Available Upgrades
login Connects and authenticates to remote server [Deprecated i
n favor of channel-login]
logout Logs out from the remote server [Deprecated in favor of c
hannel-logout]
makerpm Builds an RPM spec file from a PEAR package
package Build Package
package-dependencies Show package dependencies
package-validate Validate Package Consistency
pickle Build PECL Package
remote-info Information About Remote Packages
remote-list List Remote Packages
run-scripts Run Post-Install Scripts bundled with a package
run-tests Run Regression Tests
search Search remote package database
shell-test Shell Script Test
sign Sign a package distribution file
svntag Set SVN Release Tag
uninstall Un-install Package
update-channels Update the Channel List
upgrade Upgrade Package
upgrade-all Upgrade All Packages [Deprecated in favor of calling upgr
ade with no parameters]
Usage: pear [options] command [command-options] <parameters>
Type "pear help options" to list all options.
Type "pear help shortcuts" to list all command shortcuts.
Type "pear help <command>" to get the help for the specified command.
Polecenie [install] umożliwia instalację modułów PEAR. Pomoc dotyczącą polecenia [install] można uzyskać, wpisując:
C:\serveursSGBD\wamp21\bin\PHP\php5.3.5>pear help install
pear install [options] [channel/]<package> ...
Installs one or more PEAR packages. You can specify a package to install in four ways:
"Package-1.0.tgz" : installs from a local file
"http://example.com/Package-1.0.tgz" : installs from anywhere on the net.
"package.xml" : installs the package described in package.xml. Useful for testing, or for wrapping a PEAR package in another package manager such as RPM.
"Package[-version/state][.tar]" : queries your default channel's server(pear.php.net) and downloads the newest package with the preferred quality/state (stable).
To retrieve Package version 1.1, use "Package-1.1," to retrieve Package state beta, use "Package-beta." To retrieve an uncompressed file, append .tar (make sure there is no file by the same name first)
To download a package from another channel, prefix with the channel name like "channel/Package"
More than one package may be specified at once. It is ok to mix these four ways of specifying packages.
Options:
-f, --force
will overwrite newer installed packages
-l, --loose
do not check for recommended dependency version
-n, --nodeps
ignore dependencies, install anyway
-r, --register-only
do not install files, only register the package as installed
-s, --soft
soft install, fail silently, or upgrade if already installed
-B, --nobuild
don't build C extensions
-Z, --nocompress
request uncompressed files when downloading
-R DIR, --installroot=DIR
root directory used when installing files (ala PHP's INSTALL_ROOT), use packagingroot for RPM
-P DIR, --packagingroot=DIR
root directory used when packaging files, like RPM packaging
--ignore-errors
force install even if there were errors
-a, --alldeps
install all required and optional dependencies
-o, --onlyreqdeps
install all required dependencies
-O, --offline
do not attempt to download any urls or contact channels
-p, --pretend
Only list the packages that would be downloaded
Moduły PEAR, które należy zainstalować, to: [Mail], [Mail_Mime], [Net_SMTP]. W oknie DOS należy kolejno wpisać następujące polecenia:
<PHP_installDir>pear install Mail
...
<PHP_installDir>pear install Mail_Mime
…
<PHP_installDir>pear install Net_SMTP
…
gdzie <PHP_installDir> to folder instalacyjny interpretera PHP (w tym przykładzie: C:\serveursSGBD\wamp21\bin\PHP\php5.3.5)
Można sprawdzić zainstalowane moduły:
C:\serveursSGBD\wamp21\bin\PHP\php5.3.5>pear list
INSTALLED PACKAGES, CHANNEL PEAR.php.NET:
=========================================
PACKAGE VERSION STATE
Archive_Tar 1.3.7 stable
Console_Getopt 1.3.1 stable
Mail 1.2.0 stable
Mail_Mime 1.8.1 stable
Net_SMTP 1.6.0 stable
Net_Socket 1.0.10 stable
PEAR 1.9.4 stable
PHPUnit 1.3.2 stable
Structures_Graph 1.0.4 stable
XML_Util 1.2.1 stable
Moduły są zainstalowane w folderze <PHP_installDir>/PEAR:
 |
Po zainstalowaniu modułów PEAR skrypt PHP służący do wysyłania wiadomości e-mail wygląda następująco:
<?php
// obsługa błędów
ini_set("display_errors", "off");
// moduły
ini_set("include_path", ".;C:\serveursSGBD\wamp21\bin\PHP\php5.3.5\PEAR");
require_once "Mail.php";
require_once "Mail/Mime.php";
require_once "Net/SMTP.php";
// klient SMTP (protokół transferu SendMail) umożliwiający wysyłanie wiadomości
// dane pochodzą z pliku $INFOS zawierającego następujące wiersze
// wiersz 1: smtp, nadawca, odbiorca, załącznik
// kolejne wiersze: treść wiadomości
// nadawca: adres e-mail nadawcy
// odbiorca: adres e-mail odbiorcy
// SMTP: nazwa serwera SMTP, z którego należy korzystać
// załącznik: nazwa dokumentu do załączenia
//
// dane
$INFOS = "mail2.txt"; // parametry wysyłania wiadomości
// pobieramy parametry wiadomości
list($erreur, $smtpServer, $expéditeur, $destinataire, $message, $sujet, $attachement) = getInfos($INFOS);
// błąd?
if ($erreur) {
print "$erreur\n";
exit;
}
print "Envoi du message [$smtpServer,$expéditeur,$destinataire,$sujet, $attachement]\n";
// wysyłanie wiadomości w trybie szczegółowym
$résultat = sendmail($smtpServer, $expéditeur, $destinataire, $message, $sujet, $attachement);
print "Résultat de l'envoi : $résultat\n";
// koniec
exit;
//-----------------------------------------------------------------------
function getInfos($fichier) {
// zwraca informacje ($smtp,$expéditeur,$destinataire,$message, $sujet, $attachement) pobrane z pliku tekstowego $fichier
// wiersz 1: smtp, nadawca, odbiorca, temat, załącznik
// kolejne wiersze: treść wiadomości
...
// koniec
return array("", $smtpServer, $expéditeur, $destinataire, $message, $sujet, $attachement);
}
//getInfos
//-----------------------------------------------------------------------
function sendmail($smtpServer, $expéditeur, $destinataire, $message, $sujet, $attachement) {
// wysyła wiadomość $message na serwer SMTP $smtpserver w imieniu $expéditeur
// dla $destinataire. Do wiadomości dołączono dokument $attachement
//, a temat wiadomości to $sujet
//
// wiadomość
$msg = new Mail_Mime();
$msg->setTXTBody($message);
$msg->addAttachment($attachement);
$headers = $msg->headers(array("From" => $expéditeur, "To" => $destinataire, "Subject" => $sujet));
// wysłano
$mailer = &Mail::factory("smtp", array("host" => $smtpServer, "port" => 25));
$envoi = $mailer->send($expéditeur, $headers, $msg->get());
if ($envoi === TRUE) {
return "Message envoyé";
} else {
return $envoi;
}
}
// --------------------------------------------------------------------------
function cutNewLinechar($ligne) {
// usuwa się znak końca linii z $ligne, jeśli istnieje
…
}
Plik [mail2.txt]:
- wiersz 1: kolejno serwer SMTP, adres nadawcy, adres odbiorcy, temat wiadomości, dokument do załączenia.
- wiersze 2–4: treść wiadomości
Wyniki na ekranie
Envoi du message [smtp.orange.fr,serge.tahe@univ-angers.fr,serge.tahe@univ-angers.fr,test, document.pdf]
Résultat de l'envoi : Message envoyé
Komentarze
Skrypt różni się od poprzedniego jedynie funkcją sendmail. Opisujemy ją poniżej:
- wiersz 6: skrypty PHP z modułów PEAR zostały zainstalowane w katalogu, który domyślnie nie jest przeszukiwany przez interpreter PHP. Aby interpreter PHP mógł znaleźć moduły PEAR, sami definiujemy katalogi, które ma przeszukiwać. Podczas wykonywania można modyfikować niektóre parametry konfiguracyjne interpretera PHP. Zmiana ta jest widoczna wyłącznie dla skryptu, który ją wprowadza, i tylko na czas jego wykonywania. Domyślną konfigurację interpretera PHP można znaleźć w pliku <PHP_installdir>/PHP.ini. Plik ten zawiera wiersze o postaci
Wartość klucza można zmienić w trakcie wykonywania za pomocą funkcji ini_set(klucz, nouvelle_valeur). Kluczem określającym ścieżkę wyszukiwania przez interpreter funkcji i klas PHP, do których odwołuje się skrypt, jest „include_path”. W tym przypadku do ścieżki wyszukiwania dodajemy zarówno folder skryptu (.), jak i folder PEAR znajdujący się w folderze instalacyjnym interpretera PHP.
- wiersze 7–9: ładowane są skrypty PHP służące do wysyłania wiadomości e-mail.
- wiersz 50: funkcja sendmail odpowiedzialna za wysyłanie wiadomości e-mail. Jej parametry są następujące:
- $smtpServer: nazwa serwera SMTP, z którym należy się połączyć
- $expéditeur: adres e-mail nadawcy
- $destinataire: adres e-mail odbiorcy
- $message: treść wiadomości do wysłania.
- $sujet: temat wiadomości
- $attachement: nazwa dokumentu, który ma zostać dołączony do wiadomości
Funkcja sendMail zwraca komunikat o błędzie; jeśli nie wystąpił żaden błąd, zwraca pustą wartość.
- wiersz 56: utworzenie wiadomości typu Mail_Mime. Wiadomość ta składa się z nagłówków (From, To, Subject) oraz treści (sama wiadomość)
- wiersz 57: ustalanie treści wiadomości Mail_Mime.
- wiersz 58: do wiadomości dołączany jest dokument
- wiersz 59: ustalono nagłówki (From, To, Subject) wiadomości Mail_Mime
- wiersz 61: tworzymy klasę odpowiedzialną za wysłanie wiadomości o nazwie Mail_Mime. Pierwszym parametrem metody jest nazwa protokołu, który ma zostać użyty, w tym przypadku protokół SMTP. Drugim parametrem jest tablica określająca nazwę i port serwisu SMTP, z którego należy skorzystać
- wiersz 62: wysyłanie wiadomości. Metoda `send` przyjmuje trzy parametry: adres nadawcy, nagłówki wiadomości `Mail_Mime` oraz treść wiadomości `Mail_Mime`. Funkcja send zwraca wartość logiczną TRUE, jeśli wysłanie przebiegło pomyślnie, w przeciwnym razie zwraca komunikat o błędzie.