9. De netwerkfuncties van PHP
We gaan nu in op de netwerkfuncties van PHP waarmee we TCP / IP (Transfer Control Protocol / Internet Protocol) kunnen programmeren.
9.1. De naam of het adres IP van een computer op het internet (inet_01) opvragen
<?php
// functies: machinenaam <--> adres IP machine
ini_set("display_errors", "off");
// constanten
$HOTES = array("istia.univ-angers.fr", "www.univ-angers.fr", "www.ibm.com", "localhost", "", "xx");
// adressen IP van de machines van $HOTES
for ($i = 0; $i < count($HOTES); $i++) {
getIPandName($HOTES[$i]);
}
// einde
exit;
//------------------------------------------------
function getIPandName($nomMachine) {
//$nomMachine: naam van de machine waarvan het adres IP wordt gevraagd
// 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";
}
}
Resultaten:
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
Opmerkingen
- regel 4: er wordt aangegeven dat uitvoeringsfouten niet moeten worden weergegeven.
De netwerkfuncties van PHP worden gebruikt in de functie getIpandName op regel 15.
- regel 18: met de functie gethostbyname($nom) wordt het adres IP "ip3.ip2.ip1.ip0" van de machine met de naam $nom opgehaald. Als de machine $nom niet bestaat, geeft de functie $nom als resultaat.
- regel 22: met de functie gethostbyaddr($ip) wordt de naam van de machine met adres $ip verkregen in de vorm "ip3.ip2.ip1.ip0". Als de machine $ip niet bestaat, geeft de functie $ip als resultaat.
9.2. Een webclient ( inet_02)
Een script waarmee de inhoud van de indexpagina van een website kan worden opgehaald.
<?php
// foutbeheer
ini_set("display_errors","off");
// de tekst HTML ophalen uit URL
// lijst met websites
$SITES = array("istia.univ-angers.fr", "www.univ-angers.fr", "www.ibm.com", "xx");
// de indexpagina's van de websites uit de tabel $SITES lezen
for ($i = 0; $i < count($SITES); $i++) {
// de indexpagina van de website $SITES[$i] lezen
$résultat = getIndex($SITES[$i]);
// weergave van het resultaat
print "$résultat\n";
}//voor
// einde
exit;
//-----------------------------------------------------------------------
function getIndex($site) {
// leest URL $site/ en slaat dit op in het bestand $site.html
// het bestand $site.html aanmaken
$html = fopen("$site.html", "w");
if (!$html)
return "Erreur lors de la création du fichier $site.html";
// openen van een verbinding op poort 80 van $site
$connexion = fsockopen($site, 80);
// terugkeren bij fout
if (!$connexion)
return "Echec de la connexion au site ($site,80) : $erreur";
// $connexion vertegenwoordigt een bidirectionele communicatiestroom
// tussen de client (dit programma) en de benaderde webserver
// dit kanaal wordt gebruikt voor de uitwisseling van opdrachten en informatie
// het communicatieprotocol is HTTP
// de client verstuurt het get-commando om URL op te vragen /
// 'get'-syntaxis: URL HTTP/1.0
// de headers van het protocol HTTP moeten eindigen met een lege regel
fputs($connexion, "GET / HTTP/1.0\n\n");
// de server zal nu reageren op het kanaal $connexion. Hij zal al deze
// deze gegevens verzenden en vervolgens het kanaal sluiten. De client leest dus alles wat binnenkomt via $connexion
// totdat het kanaal wordt gesloten
while ($ligne = fgets($connexion, 1000))
fputs($html, $ligne);
// sluit de client op zijn beurt de verbinding
fclose($connexion);
// het bestand wordt gesloten $html
fclose($html);
// terug
return "Transfert réussi de la page index du site $site";
}
Resultaten: bijvoorbeeld het ontvangen bestand voor de website [www.ibm.com]:
- regels 1-11 zijn de headers van het antwoord van de server
- regel 1: de server vraagt de client om door te verwijzen naar de in regel 8 aangegeven URL
- regel 2: datum en tijdstip van het antwoord
- regel 3: identiteit van de webserver
- regel 4: door de server verzonden inhoud. Hier een pagina HTML die begint op regel 13
- regel 12: de lege regel die de headers HTTP afsluit
- regels 13-19: de pagina HTML die door de webserver is verzonden.
Opmerkingen bij de code:
- regel 7: de lijst met URL's van de websites waarvan we de indexpagina willen hebben. Deze wordt opgeslagen in het tekstbestand [nomsite.html].
- regel 11: de functie getIndex voert de taak uit
- regel 19: de functie getIndex($site) downloadt de hoofdpagina (of indexpagina) van de website $site en slaat deze op in het tekstbestand $site.html.
- regel 27: met de functie fsockopen($site,$port) kan een verbinding worden tot stand gebracht met een dienst TCP / IP die actief is op poort $port van de machine $site. Zodra de client-serververbinding tot stand is gebracht, wisselen talrijke diensten TCP / IP tekstregels uit. Dit is hier het geval bij het protocol HTTP (HyperText Transfer Protocol). De datastroom van de server naar de client kan vervolgens worden behandeld als een tekstbestand. Hetzelfde geldt voor de datastroom van de client naar de server.
- regel 38: met de functie fputs kan de client gegevens naar de server verzenden. Hier heeft de verzonden tekstregel de volgende betekenis: "Ik wil (GET) de hoofdpagina (/) van de website waarmee ik verbonden ben. Ik werk met het protocol HTTP versie 1.0". De huidige versie van dit protocol is 1.1.
- regel 42: de tekstregels van het antwoord van de server kunnen regel voor regel met een lus worden gelezen en opgeslagen in het tekstbestand. Zodra de webserver de gevraagde pagina heeft verzonden, verbreekt hij de verbinding met de client. Aan de kant van de client wordt dit gedetecteerd als een einde van het bestand.
9.3. Een SMTP-client (inet_03)
Van de protocollen TCP / IP is SMTP (SendMail Transfer Protocol) het communicatieprotocol voor de dienst voor het verzenden van berichten.
Opmerkingen:
- op een Windows-computer met antivirussoftware zal deze waarschijnlijk verhinderen dat het script PHP verbinding maakt met poort 25 van een SMTP-server. In dat geval moet de antivirussoftware worden uitgeschakeld. Voor McAfee kan men bijvoorbeeld als volgt te werk gaan:
 |
- in [1] activeer je de console VirusScan
- bij [2] wordt de service [Protection lors de l'accès] gestopt
- bij [3] is deze gestopt
Het script:
<?php
// client SMTP (SendMail Transfer Protocol) waarmee een bericht kan worden verzonden
// de gegevens worden uit een bestand gehaald met de volgende regels: $INFOS
// regel 1: smtp, afzender, ontvanger
// volgende regels: de tekst van het bericht
// afzender: e-mailadres van de afzender
// ontvanger: e-mailadres van de ontvanger
// smtp: naam van de te gebruiken smtp-server
// communicatieprotocol SMTP client-server
// -> client maakt verbinding via poort 25 van de SMTP-server
// <- de server stuurt hem een welkomstbericht
// -> de client stuurt het commando EHLO: de naam van zijn computer
// <- de server antwoordt met OK of niet
// -> de client verstuurt het commando mail from: <afzender>
// <- server antwoordt met OK of niet
// -> klant verstuurt het commando rcpt to: <ontvanger>
// <- server antwoordt met OK of niet
// -> de client verzendt het commando data
// <- server antwoordt met OK of niet
// -> de client verstuurt alle regels van zijn bericht en sluit af met een regel die het
// enige teken bevat.
// <- de server antwoordt met OK of niet
// -> de client verstuurt het quit-commando
// <- de server antwoordt met OK of niet
// de antwoorden van de server hebben de vorm xxx tekst, waarbij xxx een getal van 3 cijfers is. Elk getal xxx >=500
// duidt op een fout. Het antwoord kan uit meerdere regels bestaan die allemaal beginnen met xxx, behalve de laatste
// in de vorm xxx(spatie)
// De uitgewisselde tekstregels moeten eindigen met de tekens RC(#13) en LF(#10)
// gegevens
$INFOS = "mail.txt"; // de parameters voor het verzenden van de e-mail
// de e-mailinstellingen worden opgehaald
list($erreur, $smtpServer, $expéditeur, $destinataire, $message) = getInfos($INFOS);
// fout?
if ($erreur) {
print "$erreur\n";
exit;
}
print "Envoi du message [$smtpServer,$expéditeur,$destinataire]\n";
// e-mail verzenden in logboekmodus
$résultat = sendmail($smtpServer, $expéditeur, $destinataire, $message, 1);
print "Résultat de l'envoi : $résultat\n";
// einde
exit;
//-----------------------------------------------------------------------
function getInfos($fichier) {
// geeft de informatie weer ($smtp,$expéditeur,$destinataire,$message) uit het tekstbestand $fichier
// regel 1: smtp, afzender, ontvanger
// volgende regels: de tekst van het bericht
// het openen van $fichier
$infos = fopen($fichier, "r");
// bestaat het bestand $fichier
if (!$infos)
return array("Le fichier $fichier n'a pu être ouvert en lecture");
// de eerste regel lezen
$ligne = fgets($infos, 1000);
// verwijdering van het einde-van-regel-teken
$ligne = cutNewLineChar($ligne);
// ophalen van de velden smtp, afzender, ontvanger
$champs = explode(",", $ligne);
// hebben we het juiste aantal velden?
if (count($champs) != 3)
return "La ligne 1 du fichier $fichier (serveur smtp, expéditeur, destinataire) a un
nombre de champs incorrect";
// "verwerking" van de opgehaalde informatie
for ($i = 0; $i < count($champs); $i++)
$champs[$i] = trim($champs[$i]);
// velden ophalen
list($smtpServer, $expéditeur, $destinataire) = $champs;
// bericht lezen
$message = "";
while ($ligne = fgets($infos, 1000))
$message.=$ligne;
fclose($infos);
// terug
return array("", $smtpServer, $expéditeur, $destinataire, $message);
}
//-----------------------------------------------------------------------
function sendmail($smtpServer, $expéditeur, $destinataire, $message, $verbose) {
// verzendt $message naar de SMTP-server $smtpserver namens $expéditeur
// voor $destinataire. Als $verbose=1, houdt het de communicatie tussen client en server bij
// wordt de naam van de client opgehaald
$client = gethostbyaddr(gethostbyname(""));
// een verbinding openen op poort 25 van $smtpServer
$connexion = fsockopen($smtpServer, 25);
// terugkeren bij fout
if (!$connexion)
return "Echec de la connexion au site ($smtpServer,25)";
// $connexion vertegenwoordigt een bidirectionele communicatiestroom
// tussen de client (dit programma) en de benaderde SMTP-server
// dit kanaal wordt gebruikt voor de uitwisseling van opdrachten en informatie
// na het tot stand brengen van de verbinding stuurt de server een welkomstbericht dat wordt gelezen
$erreur = sendCommand($connexion, "", $verbose, 1);
if ($erreur) {
fclose($connexion);
return $erreur;
}
// commando ehlo:
$erreur = sendCommand($connexion, "EHLO $client", $verbose, 1);
if ($erreur) {
fclose($connexion);
return $erreur;
}
// commando mail from:
$erreur = sendCommand($connexion, "MAIL FROM: <$expéditeur>", $verbose, 1);
if ($erreur) {
fclose($connexion);
return $erreur;
}
// commando rcpt to:
$erreur = sendCommand($connexion, "RCPT TO: <$destinataire>", $verbose, 1);
if ($erreur) {
fclose($connexion);
return $erreur;
}
// commando data
$erreur = sendCommand($connexion, "DATA", $verbose, 1);
if ($erreur) {
fclose($connexion);
return $erreur;
}
// voorbereiding van het te verzenden bericht
// het moet de volgende regels bevatten
// Van: afzender
// To: ontvanger
// lege regel
// Bericht
// .
$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;
}
// commando quit
$erreur = sendCommand($connexion, "QUIT", $verbose, 1);
if ($erreur) {
fclose($connexion);
return $erreur;
}
// einde
fclose($connexion);
return "Message envoyé";
}
// --------------------------------------------------------------------------
function sendCommand($connexion, $commande, $verbose, $withRCLF) {
// verzendt $commande naar het kanaal $connexion
// logboekmodus indien $verbose=1
// als $withRCLF=1, voeg dan de reeks RCLF toe aan de uitwisseling
// gegevens
if ($withRCLF)
$RCLF = "\r\n"; else
$RCLF="";
// commando verzenden als $commande niet leeg is
if ($commande) {
fputs($connexion, "$commande$RCLF");
// eventuele echo
if ($verbose)
affiche($commande, 1);
}//if
// antwoord lezen
$réponse = fgets($connexion, 1000);
// eventuele echo
if ($verbose)
affiche($réponse, 2);
// ophalen foutcode
$codeErreur = substr($réponse, 0, 3);
// laatste regel van het antwoord?
while (substr($réponse, 3, 1) == "-") {
// antwoord lezen
$réponse = fgets($connexion, 1000);
// eventuele echo
if ($verbose)
affiche($réponse, 2);
}//while
// antwoord voltooid
// fout teruggestuurd door de server?
if ($codeErreur >= 500)
return substr($réponse, 4);
// terugkeer zonder fout
return "";
}
// --------------------------------------------------------------------------
function affiche($échange, $sens) {
// geeft $échange weer op het scherm
// als $sens=1, toon -->$echange
// als $sens=2, wordt <-- $échange weergegeven zonder de laatste 2 tekens RCLF
switch ($sens) {
case 1:
print "--> [$échange]\n";
return;
case 2:
$L = strlen($échange);
print "<-- [" . substr($échange, 0, $L - 2) . "]\n";
return;
}//schakelaar
}
// --------------------------------------------------------------------------
function cutNewLinechar($ligne) {
// het einde-van-regel-teken van $ligne wordt verwijderd, indien aanwezig
...
}
Het bestand infos.txt:
- regel 1: [smtp.orange.fr] de server die wordt gebruikt voor het verzenden van de e-mail, [serge.tahe@univ-angers.fr] het adres van de afzender, [serge.tahe@istia.univ-angers.fr] het adres van de ontvanger
- regel 2: kopteksten van het bericht. Hier is er slechts één, namelijk het onderwerp van het bericht.
- regel 3: de lege regel sluit de kopteksten van het bericht af
- regels 4-7: de tekst van het bericht
De schermresultaten:
- regel 1: bericht over de uitvoering van het script
- regel 2: eerste antwoord van de SMTP-server. Dit volgt op de verbinding van de client met poort 25 van de SMTP-server. De antwoorden van de server zijn regels in de vorm [xxx message] of [xxx-message]. De eerste syntaxis geeft aan dat het antwoord is voltooid. xxx is een resultaatcode. Een waarde groter dan of gelijk aan 500 duidt op een fout. De tweede syntaxis geeft aan dat het antwoord nog niet is voltooid en dat er nog een regel volgt.
- regel 2: de SMTP-server geeft aan dat hij klaar is om opdrachten te ontvangen
- regel 3: de client verstuurt het commando [EHLO nomDeMachine], waarbij nomDeMachine de internetnaam is van de machine waarop de client draait
- regels 4-10: antwoord van de SMTP-server
- regel 11: de client verstuurt het commando [MAIL FROM: <expéditeur>], dat het e-mailadres van de afzender aangeeft.
- regel 12: de SMTP-server geeft aan dat hij dit adres accepteert. Hij had het kunnen weigeren als de syntaxis onjuist was geweest. Hij controleert echter niet of het e-mailadres daadwerkelijk bestaat.
- regel 13: de client verstuurt het commando [RCPT TO: <destinataire>], dat het e-mailadres van de ontvanger van het bericht aangeeft.
- regel 14: de SMTP-server antwoordt dat hij dit adres accepteert. Ook hier wordt een syntaxiscontrole uitgevoerd.
- regel 15: de client verstuurt het commando [DATA], waarmee aan de gebruiker wordt aangegeven dat de volgende regels de inhoud van het bericht vormen.
- regel 16: de server antwoordt dat het bericht kan worden verzonden. Dit bericht bestaat uit een reeks tekstregels die moet eindigen met een regel die uit één enkel teken bestaat, namelijk een punt.
- regels 17-25: het door de client verzonden bericht
- regels 17-19: de kopteksten van het bericht [From:, To:, Subject:] geven respectievelijk de afzender, de ontvanger en het onderwerp van het bericht aan.
- regel 20: lege regel die het einde van de kopteksten aangeeft
- regels 21-23: de hoofdtekst van het bericht
- regel 24: de regel die bestaat uit één enkele punt en die het einde van het bericht aangeeft.
- regel 26: de SMTP-server antwoordt dat hij het bericht accepteert
- regel 27: de client verstuurt het commando [QUIT] om aan te geven dat hij klaar is
- regel 28: de SMTP-server antwoordt dat hij de verbinding met de client gaat verbreken
Opmerkingen bij de code
We zullen niet uitgebreid ingaan op de code van het script, aangezien deze al uitgebreid is voorzien van commentaar.
- regels 48-80: de functie die het bestand [infos.txt] verwerkt, dat het te verzenden bericht en de benodigde informatie voor deze verzending bevat. Deze functie retourneert een array ($erreur, $smtpServer, $expéditeur, $destinataire, $messge) met:
- $erreur: een eventuele foutmelding, anders leeg.
- $smtpServer: de naam van de SMTP-server waarmee verbinding moet worden gemaakt
- $expéditeur: het e-mailadres van de afzender
- $destinataire: het e-mailadres van de ontvanger
- $message: het te verzenden bericht. Naast de hoofdtekst van het bericht kunnen er ook headers zijn.
- regels 84-157: de functie sendMail zorgt voor het verzenden van het bericht. De parameters zijn als volgt:
- $smtpServer: de naam van de SMTP-server waarmee verbinding moet worden gemaakt
- $expéditeur: het e-mailadres van de afzender
- $destinataire: het e-mailadres van de ontvanger
- $message: het te verzenden bericht.
- $verbose: als deze waarde 1 is, moet de communicatie met de SMTP-server op de console worden weergegeven.
De functie sendMail geeft een foutmelding terug; deze is leeg als er geen fout is opgetreden.
- regel 88: hiermee kan de Windows-naam worden opgehaald van een computer die met Windows werkt via OS.
- regel 99: we hebben gezien dat de dialoog tussen client en server als volgt verloopt:
- verzending van een commando op één regel door de client
- antwoord van de server op één of meerdere regels
- regels 161-208: de functie sendCommand accepteert de volgende parameters:
- $connexion: het kanaal TCP / IP dat de client met de server verbindt
- $commande: het commando dat via dit kanaal moet worden verzonden. Het antwoord van de server op dit commando wordt weergegeven.
- $verbose: als deze waarde 1 is, geeft dit aan dat de communicatie met de SMTP-server op de console moet worden weergegeven.
- $withRCLF: als deze waarde 1 is, moet het regeleinde-teken "\r\n" aan het einde van het commando worden toegevoegd
- regel 173: verzending van het commando door de client
- regel 181: het lezen van de eerste regel van het antwoord van de SMTP-server in de vorm xxx tekst of xxx-tekst. In het laatste geval geeft dit aan dat de server nog een regel moet verzenden. xxx is de door de server verzonden foutcode.
- regel 188 – ophalen van de foutcode uit het antwoord
- regels 191-199: de overige regels van het antwoord worden gelezen
- regels 203-204: als de foutcode >=500 is, betekent dit dat de SMTP-server een fout meldt.
9.4. Een tweede programma voor het versturen van e-mail (inet_04)
Dit script heeft dezelfde functionaliteit als het vorige: het verzenden van een e-mail. Hiervoor gebruiken we modules uit de bibliotheek PEAR. Deze bibliotheek bevat tientallen modules die verschillende domeinen bestrijken. We gaan de volgende gebruiken:
- Net/SMTP: een module waarmee je kunt communiceren met een server SMTP
- Mail: een module waarmee het verzenden van een e-mail via verschillende protocollen kan worden beheerd.
- Mail/Mime: een module waarmee een bericht kan worden aangemaakt dat bijlagen kan bevatten.
Om over deze modules te kunnen beschikken, moeten ze eerst worden geïnstalleerd op de machine waarop het script PHP wordt uitgevoerd. Bij de installatie van het softwarepakket WampServer is een interpreter PHP geïnstalleerd. In de directorystructuur daarvan is het mogelijk om PEAR-modules te installeren.
 |
- in [1], de installatiemap van de interpreter PHP
- in [2], de map PEAR die de te installeren modules PEAR zal bevatten
- in [3], het commandobestand [go-pear.bat] dat de bibliotheek PEAR initialiseert
Om de bibliotheek PEAR te initialiseren, opent u een venster DOS en voert u het bestand [go-pear.bat] uit. Dit script maakt verbinding met de website van de bibliotheek PEAR. Er is dus een internetverbinding nodig.
Eenmaal verbonden met de website van de bibliotheek PEAR, zal het script een aantal elementen downloaden. Daaronder bevindt zich een nieuw script [pear.bat]. Met dit script gaan we de verschillende modules PEAR installeren die we nodig hebben. Dit script wordt met argumenten aangeroepen. Een van deze argumenten, [help], geeft een lijst weer van de commando’s die door het script worden ondersteund:
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.
Met het commando [install] kunt u PEAR-modules installeren. U kunt hulp vragen via het commando [install]:
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
De te installeren PEAR-modules zijn: [Mail], [Mail_Mime], [Net_SMTP]. In het DOS-venster voert u achtereenvolgens de volgende opdrachten in:
<PHP_installDir>pear install Mail
...
<PHP_installDir>pear install Mail_Mime
…
<PHP_installDir>pear install Net_SMTP
…
waarbij <PHP_installDir> de installatiemap is van de PHP-interpreter (in dit voorbeeld C:\serveursSGBD\wamp21\bin\PHP\php5.3.5)
Hieronder zijn de geïnstalleerde modules te zien:
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
De modules zijn geïnstalleerd in de map <PHP_installDir>/PEAR:
 |
Als de modules PEAR zijn geïnstalleerd, ziet het script PHP voor het versturen van e-mails er als volgt uit:
<?php
// foutafhandeling
ini_set("display_errors", "off");
// modules
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";
// client SMTP (SendMail Transfer Protocol) waarmee een bericht kan worden verzonden
// de gegevens zijn afkomstig uit een bestand met de naam $INFOS dat de volgende regels bevat
// regel 1: smtp, afzender, ontvanger, bijlage
// volgende regels: de tekst van het bericht
// afzender: e-mailadres van de afzender
// ontvanger: e-mailadres van de ontvanger
// smtp: naam van de te gebruiken smtp-server
// bijlage: naam van het bij te voegen document
//
// gegevens
$INFOS = "mail2.txt"; // de instellingen voor het verzenden van de e-mail
// de e-mailinstellingen worden opgehaald
list($erreur, $smtpServer, $expéditeur, $destinataire, $message, $sujet, $attachement) = getInfos($INFOS);
// fout?
if ($erreur) {
print "$erreur\n";
exit;
}
print "Envoi du message [$smtpServer,$expéditeur,$destinataire,$sujet, $attachement]\n";
// e-mail verzenden in logboekmodus
$résultat = sendmail($smtpServer, $expéditeur, $destinataire, $message, $sujet, $attachement);
print "Résultat de l'envoi : $résultat\n";
// einde
exit;
//-----------------------------------------------------------------------
function getInfos($fichier) {
// geeft de informatie weer ($smtp,$expéditeur,$destinataire,$message, $sujet, $attachement) uit het tekstbestand $fichier
// regel 1: smtp, afzender, ontvanger, onderwerp, bijlage
// volgende regels: de tekst van het bericht
...
// terug
return array("", $smtpServer, $expéditeur, $destinataire, $message, $sujet, $attachement);
}
//getInfos
//-----------------------------------------------------------------------
function sendmail($smtpServer, $expéditeur, $destinataire, $message, $sujet, $attachement) {
// verzendt $message naar de SMTP-server $smtpserver namens $expéditeur
// voor $destinataire. Het document $attachement is bij het bericht gevoegd
// het bericht heeft als onderwerp $sujet
//
// bericht
$msg = new Mail_Mime();
$msg->setTXTBody($message);
$msg->addAttachment($attachement);
$headers = $msg->headers(array("From" => $expéditeur, "To" => $destinataire, "Subject" => $sujet));
// verzending
$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) {
// de regeleinde-markering van $ligne wordt verwijderd, indien deze aanwezig is
…
}
Het bestand [mail2.txt]:
- regel 1: in volgorde de server SMTP, het adres van de afzender, het adres van de ontvanger, het onderwerp van het bericht, het bij te voegen document.
- regels 2-4: de tekst van het bericht
Schermresultaten
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é
Opmerkingen
Het script verschilt alleen van het vorige door de functie sendmail. We beschrijven deze als volgt:
- regel 6: de scripts PHP van de modules PEAR zijn geïnstalleerd in een map die standaard niet wordt doorzocht door de interpreter PHP. Om ervoor te zorgen dat de interpreter de modules PEAR kan vinden, definiëren we zelf de mappen die de interpreter PHP moet doorzoeken. Het is mogelijk om tijdens de uitvoering bepaalde configuratieparameters van de interpreter PHP te wijzigen. Deze wijziging is alleen zichtbaar voor het script dat deze aanbrengt en alleen gedurende de uitvoering ervan. De standaardconfiguratie van de interpreter PHP is te vinden in het bestand <PHP_installdir>/PHP.ini. Dit bestand bevat regels in de vorm
De waarde van de sleutel kan tijdens de uitvoering worden gewijzigd met de functie ini_set(sleutel, nouvelle_valeur). De sleutel om het zoekpad te specificeren dat de interpreter gebruikt voor de functies en klassen PHP waarnaar het script verwijst, is 'include_path'. Hier voegen we zowel de map van het script (.) als de map PEAR uit de installatiemap van de interpreter PHP toe aan het zoekpad.
- regels 7-9: de PHP-scripts voor het verzenden van e-mail worden geladen.
- regel 50: de functie sendmail die zorgt voor het verzenden van de e-mail. De parameters zijn als volgt:
- $smtpServer: de naam van de SMTP-server waarmee verbinding moet worden gemaakt
- $expéditeur: het e-mailadres van de afzender
- $destinataire: het e-mailadres van de ontvanger
- $message: het te verzenden bericht.
- $sujet: het onderwerp van het bericht
- $attachement: de naam van het document dat aan het bericht moet worden toegevoegd
De functie sendMail geeft een foutmelding terug; deze is leeg als er geen fout is opgetreden.
- regel 56: aanmaken van een bericht van het type Mail_Mime. Dit bericht bestaat uit kopteksten (From, To, Subject) en een hoofdtekst (het bericht zelf)
- regel 57: de hoofdtekst van het bericht Mail_Mime wordt vastgelegd.
- regel 58: er wordt een document aan het bericht toegevoegd
- regel 59: de kopteksten (From, To, Subject) van het bericht Mail_Mime worden vastgelegd
- regel 61: we maken de klasse aan die verantwoordelijk is voor het verzenden van het bericht Mail_Mime. De eerste parameter van de methode is de naam van het te gebruiken protocol, in dit geval het protocol SMTP. De tweede parameter is een array waarin de naam en de poort van de te gebruiken SMTP-service worden vastgelegd
- regel 62: verzending van het bericht. De methode send ontvangt drie parameters: het adres van de afzender, de headers van het bericht Mail_Mime en de tekst van het bericht Mail_Mime. De functie `send` retourneert de booleaanse waarde TRUE als het verzenden is gelukt, anders een foutmelding.