9. Funções de rede do PHP
Vamos agora discutir as funções de rede do PHP, que nos permitem realizar programação TCP/IP (Protocolo de Controlo de Transmissão/Protocolo de Internet).
9.1. Recuperação do nome ou endereço IP de uma máquina na Internet (inet_01)
<?php
// functions machine name <--> address IP machine
ini_set("display_errors", "off");
// constants
$HOTES = array("istia.univ-angers.fr", "www.univ-angers.fr", "www.ibm.com", "localhost", "", "xx");
// IP addresses of $HOTES machines
for ($i = 0; $i < count($HOTES); $i++) {
getIPandName($HOTES[$i]);
}
// end
exit;
//------------------------------------------------
function getIPandName($nomMachine) {
//$nomMachine: name of the machine whose address is required IP: name of the machine whose address is required IP: name of the machine whose address is required
// nomMachine-->adresse IP
$ip = gethostbyname($nomMachine);
if ($ip != $nomMachine) {
print "ip[$nomMachine]=$ip\n";
// address 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";
}
}
Resultados:
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
Comentários
- Linha 4: Instruímos o sistema para não exibir erros de execução.
As funções de rede do PHP são utilizadas na função getIpandName na linha 15.
- Linha 18: A função gethostbyname($name) recupera o endereço IP "ip3.ip2.ip1.ip0" da máquina denominada $name. Se a máquina $name não existir, a função devolve $name como resultado.
- Linha 22: A função gethostbyaddr($ip) recupera o nome do host da máquina com o endereço IP $ip no formato «ip3.ip2.ip1.ip0». Se a máquina $ip não existir, a função devolve $ip como resultado.
9.2. Um cliente web ( inet_02)
Um script para recuperar o conteúdo da página inicial de um site.
<?php
// error management
ini_set("display_errors","off");
// otain the text HTML from URL
// list of websites
$SITES = array("istia.univ-angers.fr", "www.univ-angers.fr", "www.ibm.com", "xx");
// reading the index pages of the sites in the $SITES table
for ($i = 0; $i < count($SITES); $i++) {
// read site index page $SITES[$i]
$résultat = getIndex($SITES[$i]);
// result display
print "$résultat\n";
}//for
// end
exit;
//-----------------------------------------------------------------------
function getIndex($site) {
// reads the URL $site/ and stores it in the $site.html file
// create file $site.html
$html = fopen("$site.html", "w");
if (!$html)
return "Erreur lors de la création du fichier $site.html";
// open a connection on port 80 of $site
$connexion = fsockopen($site, 80);
// return if error
if (!$connexion)
return "Echec de la connexion au site ($site,80) : $erreur";
// $connexion represents a bidirectional communication flow
// between the client (this program) and the contacted web server
// this channel is used for the exchange of orders and information
// the dialog protocol is HTTP
// the customer sends the get command to request URL /
// syntaxe get URL HTTP/1.0
// protocol HTTP headers must end with an empty line
fputs($connexion, "GET / HTTP/1.0\n\n");
// the server will now respond on channel $connexion. It will send all
// then close the channel. The client therefore reads everything that arrives from $connexion
// until the channel closes
while ($ligne = fgets($connexion, 1000))
fputs($html, $ligne);
// the customer in turn closes the connection
fclose($connexion);
// close file $html
fclose($html);
// return
return "Transfert réussi de la page index du site $site";
}
Resultados: por exemplo, o ficheiro recebido para o site [www.ibm.com]:
- As linhas 1–11 são os cabeçalhos HTTP da resposta do servidor
- linha 1: o servidor instrui o cliente a redirecionar para o URL especificado na linha 8
- linha 2: data e hora da resposta
- linha 3: identidade do servidor web
- Linha 4: Conteúdo enviado pelo servidor. Aqui, uma página HTML que começa na linha 13
- Linha 12: A linha vazia que encerra os cabeçalhos HTTP
- Linhas 13–19: A página HTML enviada pelo servidor web.
Comentários de código:
- linha 7: a lista de URLs dos sites cujas páginas de índice pretendemos. Estas serão armazenadas no ficheiro de texto [sitename.html].
- Linha 11: A função getIndex realiza o trabalho
- linha 19: a função getIndex($site) descarrega a página raiz (ou página de índice) do site $site e armazena-a no ficheiro de texto $site.html.
- linha 27: a função fsockopen($site,$port) estabelece uma ligação com um serviço TCP/IP em execução na porta $port da máquina $site. Assim que a ligação cliente/servidor é estabelecida, muitos serviços TCP/IP trocam linhas de texto. É o que acontece aqui com o HTTP (HyperText Transfer Protocol). O fluxo de dados do servidor para o cliente pode então ser tratado como um ficheiro de texto. O mesmo se aplica ao fluxo de dados do cliente para o servidor.
- Linha 38: A função fputs permite que o cliente envie dados para o servidor. Aqui, a linha de texto enviada tem o seguinte significado: «Quero (GET) a página raiz (/) do site ao qual estou ligado. Estou a utilizar a versão 1.0 do HTTP.» A versão atual deste protocolo é a 1.1.
- Linha 42: As linhas de texto da resposta do servidor podem ser lidas linha a linha utilizando um ciclo while e guardadas no ficheiro de texto [$site.html]. Assim que o servidor web enviar a página solicitada, encerra a sua ligação com o cliente. No lado do cliente, isto será detetado como um fim de ficheiro.
9.3. Um cliente SMTP (inet_03)
Entre os protocolos TCP/IP, o SMTP (Simple Mail Transfer Protocol) é o protocolo de comunicação para o serviço de entrega de correio.
Notas:
- Num computador Windows com software antivírus, é provável que o antivírus impeça o script PHP de se ligar à porta 25 de um servidor SMTP. Por isso, deve desativar o antivírus. No caso do McAfee, por exemplo, pode fazer o seguinte:
 |
- Em [1], abra a consola do VirusScan
- Em [2], interrompa o serviço [On-Access Protection]
- em [3], o serviço está parado
O script:
<?php
// client SMTP (SendMail Transfer Protocol) for sending a message
// information is taken from a $INFOS file containing the following lines
// line 1: smtp, sender, recipient
// next lines: message text
// sender: email sender
// recipient: email recipient
// smtp: name of smtp server to use
// communication protocol SMTP client-server
// -> client connects to smtp server port 25
// <- server sends him a welcome message
// -> customer sends command EHLO: machine name
// <- server responds OK or not
// -> customer sends mail order from: <sender>
// <- server responds OK or not
// -> client sends the rcpt to command: <recipient>
// <- server responds OK or not
// -> customer sends data order
// <- server responds OK or not
// -> client sends all the lines of its message and ends with a line containing the
// single character .
// <- server responds OK or not
// -> customer sends quit order
// <- server responds OK or not
// server responses have the form xxx text where xxx is a 3-digit number. Any number xxx >=500
// indicates an error. The answer may consist of several lines all beginning with xxx except the last one
// of the form xxx(space)
// exchanged text lines must end with the characters RC(#13) and LF(#10)
// data
$INFOS = "mail.txt"; // mail settings
// retrieve mail parameters
list($erreur, $smtpServer, $expéditeur, $destinataire, $message) = getInfos($INFOS);
// mistake?
if ($erreur) {
print "$erreur\n";
exit;
}
print "Envoi du message [$smtpServer,$expéditeur,$destinataire]\n";
// sending mail in verbose mode
$résultat = sendmail($smtpServer, $expéditeur, $destinataire, $message, 1);
print "Résultat de l'envoi : $résultat\n";
// end
exit;
//-----------------------------------------------------------------------
function getInfos($fichier) {
// returns information ($smtp,$expéditeur,$destinataire,$message) taken from text file $fichier
// line 1: smtp, sender, recipient
// next lines: message text
// opening of $fichier
$infos = fopen($fichier, "r");
// does the $fichier file exist?
if (!$infos)
return array("Le fichier $fichier n'a pu être ouvert en lecture");
// read the 1st line
$ligne = fgets($infos, 1000);
// delete end-of-line mark
$ligne = cutNewLineChar($ligne);
// retrieving smtp, sender and recipient fields
$champs = explode(",", $ligne);
// do we have the right number of fields?
if (count($champs) != 3)
return "La ligne 1 du fichier $fichier (serveur smtp, expéditeur, destinataire) a un
nombre de champs incorrect";
// "processing" the recovered information
for ($i = 0; $i < count($champs); $i++)
$champs[$i] = trim($champs[$i]);
// field recovery
list($smtpServer, $expéditeur, $destinataire) = $champs;
// read message
$message = "";
while ($ligne = fgets($infos, 1000))
$message.=$ligne;
fclose($infos);
// return
return array("", $smtpServer, $expéditeur, $destinataire, $message);
}
//-----------------------------------------------------------------------
function sendmail($smtpServer, $expéditeur, $destinataire, $message, $verbose) {
// sends $message to smtp server $smtpserver from $expéditeur
// for $destinataire. If $verbose=1, tracks client-server exchanges
// retrieve the customer's name
$client = gethostbyaddr(gethostbyname(""));
// open a connection on port 25 of $smtpServer
$connexion = fsockopen($smtpServer, 25);
// return if error
if (!$connexion)
return "Echec de la connexion au site ($smtpServer,25)";
// $connexion represents a bidirectional communication flow
// between the client (this program) and the smtp server contacted
// this channel is used for the exchange of orders and information
// after connection, the server sends a welcome message which is read as follows
$erreur = sendCommand($connexion, "", $verbose, 1);
if ($erreur) {
fclose($connexion);
return $erreur;
}
// cmde ehlo:
$erreur = sendCommand($connexion, "EHLO $client", $verbose, 1);
if ($erreur) {
fclose($connexion);
return $erreur;
}
// cmde mail from:
$erreur = sendCommand($connexion, "MAIL FROM: <$expéditeur>", $verbose, 1);
if ($erreur) {
fclose($connexion);
return $erreur;
}
// cmde rcpt to:
$erreur = sendCommand($connexion, "RCPT TO: <$destinataire>", $verbose, 1);
if ($erreur) {
fclose($connexion);
return $erreur;
}
// cmde data
$erreur = sendCommand($connexion, "DATA", $verbose, 1);
if ($erreur) {
fclose($connexion);
return $erreur;
}
// prepare message to send
// it must contain the lines
// From: expéditeur
// To: recipient
// blank line
// Message
// .
$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;
}
// cmde quit
$erreur = sendCommand($connexion, "QUIT", $verbose, 1);
if ($erreur) {
fclose($connexion);
return $erreur;
}
// end
fclose($connexion);
return "Message envoyé";
}
// --------------------------------------------------------------------------
function sendCommand($connexion, $commande, $verbose, $withRCLF) {
// sends $commande to the $connexion channel
// verbose mode if $verbose=1
// if $withRCLF=1, adds sequence RCLF to exchange
// data
if ($withRCLF)
$RCLF = "\r\n"; else
$RCLF="";
// send cmde if $commande not empty
if ($commande) {
fputs($connexion, "$commande$RCLF");
// possible echo
if ($verbose)
affiche($commande, 1);
}////if
// reading response
$réponse = fgets($connexion, 1000);
// possible echo
if ($verbose)
affiche($réponse, 2);
// error code recovery
$codeErreur = substr($réponse, 0, 3);
// last line of the answer?
while (substr($réponse, 3, 1) == "-") {
// reading response
$réponse = fgets($connexion, 1000);
// possible echo
if ($verbose)
affiche($réponse, 2);
}////while
// answer completed
// error returned by the server?
if ($codeErreur >= 500)
return substr($réponse, 4);
// error-free return
return "";
}
// --------------------------------------------------------------------------
function affiche($échange, $sens) {
// displays $échange on screen
// if $sens=1 displays -->$echange
// if $sens=2 displays <-- $échange without the last 2 characters RCLF
switch ($sens) {
case 1:
print "--> [$échange]\n";
return;
case 2:
$L = strlen($échange);
print "<-- [" . substr($échange, 0, $L - 2) . "]\n";
return;
}////switch
}
// --------------------------------------------------------------------------
function cutNewLinechar($ligne) {
// delete the end-of-line mark from $ligne if it exists
...
}
O ficheiro infos.txt:
- linha 1: [smtp.orange.fr] o servidor utilizado para enviar o e-mail, [serge.tahe@univ-angers.fr] o endereço do remetente, [serge.tahe@istia.univ-angers.fr] o endereço do destinatário
- linha 2: cabeçalhos da mensagem. Aqui existe apenas um, o assunto da mensagem.
- linha 3: a linha em branco encerra os cabeçalhos da mensagem
- linhas 4–7: o corpo da mensagem
Resultados no ecrã:
- linha 1: mensagem de acompanhamento da execução do script
- linha 2: primeira resposta do servidor SMTP. Isto segue-se à ligação do cliente à porta 25 do servidor SMTP. As respostas do servidor são linhas no formato [xxx mensagem] ou [xxx-mensagem]. A primeira sintaxe indica que a resposta está completa. xxx é um código de estado. Um valor maior ou igual a 500 indica um erro. A segunda sintaxe indica que a resposta não está completa e que se seguirá outra linha.
- Linha 2: O servidor SMTP indica que está pronto para receber comandos
- Linha 3: o cliente envia o comando [EHLO machineName], em que machineName é o nome de host da máquina na qual o cliente está a ser executado
- Linhas 4–10: Resposta do servidor SMTP
- linha 11: o cliente envia o comando [MAIL FROM: <remetente>], que especifica o endereço de e-mail do remetente.
- Linha 12: O servidor SMTP indica que aceita este endereço. Poderia tê-lo rejeitado se a sintaxe estivesse incorreta. Dito isto, não verifica se o endereço de e-mail existe realmente.
- linha 13: o cliente envia o comando [RCPT TO: <destinatário>], que especifica o endereço de e-mail do destinatário da mensagem.
- Linha 14: O servidor SMTP responde que aceita este endereço. Mais uma vez, é realizada uma verificação de sintaxe.
- Linha 15: O cliente envia o comando [DATA], que indica ao utilizador que as linhas que se seguem constituem o corpo da mensagem.
- Linha 16: O servidor responde que a mensagem pode ser enviada. A mensagem é uma sequência de linhas de texto que deve terminar com uma linha de um único caractere: um ponto.
- Linhas 17–25: A mensagem enviada pelo cliente
- Linhas 17–19: Os cabeçalhos da mensagem [From:, To:, Subject:] indicam o remetente, o destinatário e o assunto da mensagem, respetivamente.
- Linha 20: Uma linha vazia indicando o fim dos cabeçalhos
- Linhas 21–23: o corpo da mensagem
- Linha 24: a linha composta por um único ponto que sinaliza o fim da mensagem.
- Linha 26: O servidor SMTP responde que aceita a mensagem
- Linha 27: o cliente envia o comando [QUIT] para indicar que terminou
- Linha 28: O servidor SMTP responde que irá encerrar a ligação com o cliente
Comentários do código
Não entraremos em muitos detalhes sobre o código do script, uma vez que este já foi amplamente comentado.
- Linhas 48–80: A função que processa o ficheiro [infos.txt], que contém a mensagem a enviar juntamente com as informações necessárias para o seu envio. Ela devolve um array ($error, $smtpServer, $sender, $recipient, $message) com:
- $error: uma possível mensagem de erro; vazio caso contrário.
- $smtpServer: o nome do servidor SMTP ao qual se deve ligar
- $sender: o endereço de e-mail do remetente
- $recipient: o endereço de e-mail do destinatário
- $message: a mensagem a ser enviada. Além do corpo da mensagem, pode haver cabeçalhos.
- linhas 84-157: a função sendMail é responsável pelo envio da mensagem. Os seus parâmetros são os seguintes:
- $smtpServer: o nome do servidor SMTP ao qual se deve ligar
- $sender: o endereço de e-mail do remetente
- $recipient: o endereço de e-mail do destinatário
- $message: a mensagem a ser enviada.
- $verbose: se definido como 1, indica que a comunicação com o servidor SMTP deve ser registada na consola.
A função sendMail devolve uma mensagem de erro; devolve uma cadeia de caracteres vazia se não houver erros.
- Linha 88: recupera o nome Windows de um computador que executa o sistema operativo Windows.
- linha 99: vimos que o diálogo cliente/servidor segue este padrão:
- o cliente envia um comando numa única linha
- resposta do servidor em uma ou mais linhas
- Linhas 161–208: A função `sendCommand` aceita os seguintes parâmetros:
- $connection: o canal TCP/IP que liga o cliente ao servidor
- $command: o comando a ser enviado por este canal. A resposta do servidor a este comando será lida.
- $verbose: definido como 1 indica que as trocas com o servidor SMTP devem ser exibidas na consola.
- $withRCLF: definido como 1 indica que o marcador de fim de linha "\r\n" deve ser adicionado ao final do comando
- linha 173: o cliente envia o comando
- linha 181: leitura da primeira linha da resposta do servidor SMTP na forma xxx texto ou xxx-texto. O último caso indica que o servidor tem outra linha para enviar. xxx é o código de erro enviado pelo servidor.
- linha 188 – recuperação do código de erro da resposta
- linhas 191–199: leitura das outras linhas da resposta
- linhas 203–204: se o código de erro for >=500, então o servidor SMTP está a reportar um erro.
9.4. Um segundo programa para enviar e-mail (inet_04)
Este script tem a mesma funcionalidade que o anterior: enviar um e-mail. Utilizamos módulos da biblioteca PEAR para isso. Esta biblioteca contém dezenas de módulos que abrangem vários campos. Iremos utilizar os seguintes:
- Net/SMTP: um módulo para comunicação com um servidor SMTP
- Mail: um módulo para gerir o envio de e-mail utilizando vários protocolos.
- Mail/Mime: um módulo para criar uma mensagem que pode incluir documentos anexados.
Para utilizar estes módulos, deve primeiro instalá-los na máquina que executa o script PHP. A instalação do pacote de software WampServer instalou um interpretador PHP. Dentro da sua estrutura de diretórios, pode instalar módulos PEAR.
 |
- em [1], o diretório de instalação do interpretador PHP
- em [2], a pasta PEAR que irá conter os módulos PEAR a instalar
- [3] é o ficheiro de lote [go-pear.bat] que inicializa a biblioteca PEAR
Para inicializar a biblioteca PEAR, abra uma janela do DOS e execute o ficheiro [go-pear.bat]. Este script irá ligar-se ao site da biblioteca PEAR. Por isso, é necessária uma ligação à Internet.
Uma vez ligado ao site da biblioteca PEAR, o script irá descarregar vários itens. Entre estes encontra-se um novo script [pear.bat]. Iremos utilizar este script para instalar os vários módulos PEAR de que necessitamos. Este script é chamado com argumentos. Entre estes, o argumento [help] fornece uma lista de comandos aceites pelo script:
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.
O comando [install] é utilizado para instalar módulos PEAR. Pode obter ajuda sobre o comando [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
Os módulos PEAR a instalar são: [Mail], [Mail_Mime], [Net_SMTP]. Na janela do Prompt de Comando, introduza os seguintes comandos, um após o outro:
<PHP_installDir>pear install Mail
...
<PHP_installDir>pear install Mail_Mime
…
<PHP_installDir>pear install Net_SMTP
…
onde <PHP_installDir> é o diretório de instalação do interpretador PHP (C:\serveursSGBD\wamp21\bin\PHP\php5.3.5 neste exemplo)
Pode ver os módulos instalados:
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
Os módulos estão instalados na pasta <PHP_installDir>/PEAR:
 |
Com os módulos PEAR instalados, o script PHP para enviar e-mails fica assim:
<?php
// error management
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) for sending a message
// information is taken from a $INFOS file containing the following lines
// line 1: smtp, sender, recipient, attachment
// next lines: message text
// sender:email sender
// recipient: email recipient
// smtp: name of smtp server to use
// attachment: name of the document to be attached
//
// data
$INFOS = "mail2.txt"; // mail settings
// retrieve mail parameters
list($erreur, $smtpServer, $expéditeur, $destinataire, $message, $sujet, $attachement) = getInfos($INFOS);
// mistake?
if ($erreur) {
print "$erreur\n";
exit;
}
print "Envoi du message [$smtpServer,$expéditeur,$destinataire,$sujet, $attachement]\n";
// sending mail in verbose mode
$résultat = sendmail($smtpServer, $expéditeur, $destinataire, $message, $sujet, $attachement);
print "Résultat de l'envoi : $résultat\n";
// end
exit;
//-----------------------------------------------------------------------
function getInfos($fichier) {
// returns information ($smtp,$expéditeur,$destinataire,$message, $sujet, $attachement) taken from text file $fichier
// line 1: smtp, sender, recipient, subject, attachment
// next lines: message text
...
// return
return array("", $smtpServer, $expéditeur, $destinataire, $message, $sujet, $attachement);
}
//getInfos
//-----------------------------------------------------------------------
function sendmail($smtpServer, $expéditeur, $destinataire, $message, $sujet, $attachement) {
// sends $message to smtp server $smtpserver from $expéditeur
// for $destinataire. Document $attachement is attached to the message
// message has subject $sujet
//
// message
$msg = new Mail_Mime();
$msg->setTXTBody($message);
$msg->addAttachment($attachement);
$headers = $msg->headers(array("From" => $expéditeur, "To" => $destinataire, "Subject" => $sujet));
// shipping
$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) {
// delete the end-of-line mark from $ligne if it exists
…
}
O ficheiro [mail2.txt]:
- linha 1: por ordem, o servidor SMTP, o endereço do remetente, o endereço do destinatário, o assunto da mensagem, o documento a anexar.
- linhas 2-4: o texto da mensagem
Resultados no ecrã
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é
Comentários
Este script difere do anterior apenas na utilização da função sendmail. Descrevemos esta função abaixo:
- Linha 6: Os scripts PHP para os módulos PEAR foram instalados num diretório que o interpretador PHP não pesquisa por padrão. Para garantir que o interpretador consiga encontrar os módulos PEAR, especificamos manualmente os diretórios que ele deve pesquisar. É possível modificar certos parâmetros de configuração do interpretador PHP em tempo de execução. Esta modificação é visível apenas para o script que a efetua e apenas durante o período da sua execução. A configuração padrão do interpretador PHP pode ser encontrada no ficheiro <PHP_installdir>/PHP.ini. Este ficheiro contém linhas do tipo
O valor da chave pode ser modificado em tempo de execução utilizando a função ini_set(key, new_value). A chave utilizada para especificar o caminho de pesquisa para funções e classes PHP referenciadas pelo script é 'include_path'. Aqui, adicionamos tanto o diretório do script (.) como o diretório PEAR dentro do diretório de instalação do interpretador PHP ao caminho de pesquisa.
- Linhas 7–9: Os scripts PHP para o envio de e-mail são carregados.
- linha 50: a função sendmail, que trata do envio do e-mail. Os seus parâmetros são os seguintes:
- $smtpServer: o nome do servidor SMTP ao qual se deve ligar
- $sender: o endereço de e-mail do remetente
- $recipient: o endereço de e-mail do destinatário
- $message: a mensagem a enviar.
- $subject: o assunto da mensagem
- $attachment: o nome do documento a anexar à mensagem
A função sendMail devolve uma mensagem de erro; fica vazia se não ocorrer nenhum erro.
- Linha 56: criação de uma mensagem Mail_Mime. Esta mensagem é composta por cabeçalhos (De, Para, Assunto) e um corpo (a própria mensagem)
- Linha 57: O corpo da mensagem Mail_Mime é definido.
- linha 58: anexar um documento à mensagem
- Linha 59: Definição dos cabeçalhos (From, To, Subject) da mensagem Mail_Mime
- linha 61: cria a classe responsável pelo envio da mensagem Mail_Mime. O primeiro parâmetro do método é o nome do protocolo a utilizar, neste caso o protocolo SMTP. O segundo parâmetro é uma matriz que especifica o nome e a porta do serviço SMTP a utilizar
- linha 62: envio da mensagem. O método send recebe três parâmetros: o endereço do remetente, os cabeçalhos da mensagem Mail_Mime e o corpo da mensagem Mail_Mime. A função send retorna o valor booleano TRUE se a mensagem foi enviada com sucesso, ou uma mensagem de erro caso contrário.