www/plugins/facteur/inc/envoyer_mail.php

   1 <?php
   2 /*
   3  * Plugin Facteur 2
   4  * (c) 2009-2011 Collectif SPIP
   5  * Distribue sous licence GPL
   6  *
   7  */
   8
   9 if (!defined("_ECRIRE_INC_VERSION")) return;
  10
  11 include_spip('classes/facteur');
  12 // inclure le fichier natif de SPIP, pour les fonctions annexes
  13 include_once _DIR_RESTREINT."inc/envoyer_mail.php";
  14
  15 /**
  16  * @param string $destinataire
  17  * @param string $sujet
  18  * @param string|array $corps
  19  *   au format string, c'est un corps d'email au format texte, comme supporte nativement par le core
  20  *   au format array, c'est un corps etendu qui peut contenir
  21  *     string texte : le corps d'email au format texte
  22  *     string html : le corps d'email au format html
  23  *     string from : email de l'envoyeur (prioritaire sur argument $from de premier niveau, deprecie)
  24  *     string nom_envoyeur : un nom d'envoyeur pour completer l'email from
  25  *     string cc : destinataires en copie conforme
  26  *     string bcc : destinataires en copie conforme cachee
  27  *     string|array repondre_a : une ou plusieurs adresses à qui répondre.
  28  *       On peut aussi donner une liste de tableaux du type :
  29  *         array('email' => 'test@exemple.com', 'nom' => 'Adresse de test')
  30  *       pour spécifier un nom d'envoyeur pour chaque adresse.
  31  *     string nom_repondre_a : le nom d'envoyeur pour compléter l'email repondre_a
  32  *     string adresse_erreur : addresse de retour en cas d'erreur d'envoi
  33  *     array pieces_jointes : listes de pieces a embarquer dans l'email, chacune au format array :
  34  *       string chemin : chemin file system pour trouver le fichier a embarquer
  35  *       string nom : nom du document tel qu'apparaissant dans l'email
  36  *       string encodage : encodage a utiliser, parmi 'base64', '7bit', '8bit', 'binary', 'quoted-printable'
  37  *       string mime : mime type du document
  38  *     array headers : tableau d'en-tetes personalises, une entree par ligne d'en-tete
  39  *     bool exceptions : lancer une exception en cas d'erreur (false par defaut)
  40  * @param string $from (deprecie, utiliser l'entree from de $corps)
  41  * @param string $headers (deprecie, utiliser l'entree headers de $corps)
  42  * @return bool
  43  */
  44 function inc_envoyer_mail($destinataire, $sujet, $corps, $from = "", $headers = "") {
  45         $message_html   = '';
  46         $message_texte  = '';
  47         $nom_envoyeur = $cc = $bcc = $repondre_a = '';
  48         $pieces_jointes = array();
  49
  50         // si $corps est un tableau -> fonctionnalites etendues
  51         // avec entrees possible : html, texte, pieces_jointes, nom_envoyeur, ...
  52         if (is_array($corps)) {
  53                 $message_html   = isset($corps['html']) ? $corps['html'] : "";
  54                 $message_texte  = isset($corps['texte']) ? nettoyer_caracteres_mail($corps['texte']) : "";
  55                 $pieces_jointes = isset($corps['pieces_jointes']) ? $corps['pieces_jointes'] : array();
  56                 $nom_envoyeur   = isset($corps['nom_envoyeur']) ? $corps['nom_envoyeur'] : "";
  57                 $from = isset($corps['from']) ? $corps['from']: $from;
  58                 $cc   = isset($corps['cc']) ? $corps['cc'] : "";
  59                 $bcc  = isset($corps['bcc']) ? $corps['bcc'] : "";
  60                 $repondre_a = isset($corps['repondre_a']) ? $corps['repondre_a'] : "";
  61                 $nom_repondre_a = isset($corps['nom_repondre_a']) ? $corps['nom_repondre_a'] : '';
  62                 $adresse_erreur = isset($corps['adresse_erreur']) ? $corps['adresse_erreur'] : "";
  63                 $headers = isset($corps['headers']) ? $corps['headers'] : $headers;
  64                 if (is_string($headers)){
  65                         $headers = array_map('trim',explode("\n",$headers));
  66                         $headers = array_filter($headers);
  67                 }
  68         }
  69         // si $corps est une chaine -> compat avec la fonction native SPIP
  70         // gerer le cas ou le corps est du html avec un Content-Type: text/html dans les headers
  71         else {
  72                 if (preg_match(',Content-Type:\s*text/html,ims',$headers)){
  73                         $message_html   = $corps;
  74                 }
  75                 else {
  76                         // Autodetection : tester si le mail est en HTML
  77                         if (strpos($headers,"Content-Type:")===false
  78                                 AND strpos($corps,"<")!==false // eviter les tests suivants si possible
  79                                 AND $ttrim = trim($corps)
  80                                 AND substr($ttrim,0,1)=="<"
  81                                 AND substr($ttrim,-1,1)==">"
  82                                 AND stripos($ttrim,"</html>")!==false){
  83
  84                                 if(!strlen($sujet)){
  85                                         // dans ce cas on ruse un peu : extraire le sujet du title
  86                                         if (preg_match(",<title>(.*)</title>,Uims",$corps,$m))
  87                                                 $sujet = $m[1];
  88                                         else {
  89                                                 // fallback, on prend le body si on le trouve
  90                                                 if (preg_match(",<body[^>]*>(.*)</body>,Uims",$corps,$m))
  91                                                         $ttrim = $m[1];
  92
  93                                                 // et on extrait la premiere ligne de vrai texte...
  94                                                 // nettoyer le html et les retours chariots
  95                                                 $ttrim = textebrut($ttrim);
  96                                                 $ttrim = str_replace("\r\n", "\r", $ttrim);
  97                                                 $ttrim = str_replace("\r", "\n", $ttrim);
  98                                                 // decouper
  99                                                 $ttrim = explode("\n",trim($ttrim));
 100                                                 // extraire la premiere ligne de texte brut
 101                                                 $sujet = array_shift($ttrim);
 102                                         }
 103                                 }
 104                                 $message_html   = $corps;
 105                         }
 106                         // c'est vraiment un message texte
 107                         else
 108                                 $message_texte  = nettoyer_caracteres_mail($corps);
 109                 }
 110                 $headers = array_map('trim',explode("\n",$headers));
 111                 $headers = array_filter($headers);
 112         }
 113         $sujet = nettoyer_titre_email($sujet);
 114
 115         // si le mail est en texte brut, on l'encapsule dans un modele surchargeable
 116         // pour garder le texte brut, il suffit de faire un modele qui renvoie uniquement #ENV*{texte}
 117         if ($message_texte AND ! $message_html){
 118                 $message_html = recuperer_fond("emails/texte",array('texte'=>$message_texte,'sujet'=>$sujet));
 119         }
 120         // si le mail est en HTML sans alternative, la generer
 121         if ($message_html AND !$message_texte){
 122                 $message_texte = facteur_mail_html2text($message_html);
 123         }
 124
 125         $exceptions = false;
 126         if (is_array($corps) AND isset($corps['exceptions'])){
 127                 $exceptions = $corps['exceptions'];
 128         }
 129
 130         // mode TEST : forcer l'email
 131         if (defined('_TEST_EMAIL_DEST')) {
 132                 if (!_TEST_EMAIL_DEST){
 133                         spip_log($e="Envois bloques par la constante _TEST_EMAIL_DEST", 'mail.' . _LOG_ERREUR);
 134                         if ($exceptions) {
 135                                 throw new Exception($e);
 136                         }
 137                         return false;
 138                 }
 139                 else
 140                         $destinataire = _TEST_EMAIL_DEST;
 141         }
 142
 143         // plusieurs destinataires peuvent etre fournis separes par des virgules
 144         // c'est un format standard dans l'envoi de mail
 145         // les passer au format array pour phpMailer
 146         // mais ne pas casser si on a deja un array en entree
 147         // si pas destinataire du courriel on renvoie false (eviter les warning PHP : ligne 464 de phpmailer-php5/class.phpmailer.php
 148         // suppression des adresses de courriels invalides, si aucune valide, renvoyer false (eviter un warning PHP : ligne 464 de phpmailer-php5/class.phpmailer.php)
 149         if (is_array($destinataire))
 150                 $destinataire = implode(", ",$destinataire);
 151
 152         if(strlen($destinataire) > 0){
 153                 $destinataire = array_map('trim',explode(",",$destinataire));
 154                 foreach ($destinataire as $key => $value) {
 155                         if(!email_valide($value))
 156                                 unset($destinataire[$key]);
 157                 }
 158                 if(count($destinataire) == 0) {
 159                         spip_log($e="Aucune adresse email de destination valable pour l'envoi du courriel.", 'mail.' . _LOG_ERREUR);
 160                         if ($exceptions) {
 161                                 throw new Exception($e);
 162                         }
 163                         return false;
 164                 }
 165         }
 166         else {
 167                 if ($bcc) {
 168                         // On peut envoyer de mail que en bcc
 169                         $destinataire = '';
 170                 } else {
 171                         spip_log($e="Aucune adresse email de destination valable pour l'envoi du courriel.", 'mail.' . _LOG_ERREUR);
 172                         if ($exceptions) {
 173                                 throw new Exception($e);
 174                         }
 175                         return false;
 176                 }
 177         }
 178
 179         // On crée l'objet Facteur (PHPMailer) pour le manipuler ensuite
 180         $facteur = new Facteur($destinataire, $sujet, $message_html, $message_texte);
 181         if (is_array($corps) AND isset($corps['exceptions'])){
 182                 $facteur->SetExceptions($corps['exceptions']);
 183         }
 184
 185         // On ajoute le courriel de l'envoyeur s'il est fournit par la fonction
 186         if (empty($from) AND empty($facteur->From)) {
 187                 $from = $GLOBALS['meta']["email_envoi"];
 188                 if (empty($from) OR !email_valide($from)) {
 189                         spip_log("Meta email_envoi invalide. Le mail sera probablement vu comme spam.", 'mail.' . _LOG_ERREUR);
 190                         if(is_array($destinataire) && count($destinataire) > 0)
 191                                 $from = $destinataire[0];
 192                         else
 193                                 $from = $destinataire;
 194                 }
 195         }
 196
 197         // "Marie Toto <Marie@toto.com>"
 198         if (preg_match(",^([^<>\"]*)<([^<>\"]+)>$,i",$from,$m)){
 199                 $nom_envoyeur = trim($m[1]);
 200                 $from = trim($m[2]);
 201         }
 202         if (!empty($from)){
 203                 $facteur->From = $from;
 204                 // la valeur par défaut de la config n'est probablement pas valable pour ce mail,
 205                 // on l'écrase pour cet envoi
 206                 $facteur->FromName = $from;
 207         }
 208
 209         // On ajoute le nom de l'envoyeur s'il fait partie des options
 210         if ($nom_envoyeur)
 211                 $facteur->FromName = $nom_envoyeur;
 212
 213         // Si plusieurs emails dans le from, pas de Name !
 214         if (strpos($facteur->From,",")!==false){
 215                 $facteur->FromName = "";
 216         }
 217
 218         // S'il y a des copies à envoyer
 219         if ($cc){
 220                 if (is_array($cc))
 221                         foreach ($cc as $courriel)
 222                                 $facteur->AddCC($courriel);
 223                 else
 224                         $facteur->AddCC($cc);
 225         }
 226
 227         // S'il y a des copies cachées à envoyer
 228         if ($bcc){
 229                 if (is_array($bcc))
 230                         foreach ($bcc as $courriel)
 231                                 $facteur->AddBCC($courriel);
 232                 else
 233                         $facteur->AddBCC($bcc);
 234         }
 235
 236         // S'il y a une adresse de reply-to
 237         if ($repondre_a) {
 238                 if (is_array($repondre_a)) {
 239                         foreach ($repondre_a as $courriel) {
 240                                 if (is_array($courriel)) {
 241                                         $facteur->AddReplyTo($courriel['email'], $courriel['nom']);
 242                                 } else {
 243                                         $facteur->AddReplyTo($courriel);
 244                                 }
 245                         }
 246                 } elseif ($nom_repondre_a) {
 247                         $facteur->AddReplyTo($repondre_a, $nom_repondre_a);
 248                 } else {
 249                         $facteur->AddReplyTo($repondre_a);
 250                 }
 251         }
 252
 253         // S'il y a des pièces jointes on les ajoute proprement
 254         if (count($pieces_jointes)) {
 255                 foreach ($pieces_jointes as $piece) {
 256                         $facteur->AddAttachment(
 257                                 $piece['chemin'],
 258                                 isset($piece['nom']) ? $piece['nom']:'',
 259                                 (isset($piece['encodage']) AND in_array($piece['encodage'],array('base64', '7bit', '8bit', 'binary', 'quoted-printable'))) ? $piece['encodage']:'base64',
 260                                 isset($piece['mime']) ? $piece['mime']:Facteur::_mime_types(pathinfo($piece['chemin'], PATHINFO_EXTENSION))
 261                         );
 262                 }
 263         }
 264
 265         // Si une adresse email a été spécifiée pour les retours en erreur, on l'ajoute
 266         if (!empty($adresse_erreur))
 267                 $facteur->Sender = $adresse_erreur;
 268
 269         // si entetes personalises : les ajouter
 270         // attention aux collisions : si on utilise l'option cc de $corps
 271         // et qu'on envoie en meme temps un header Cc: xxx, yyy
 272         // on aura 2 lignes Cc: dans les headers
 273         if (!empty($headers)) {
 274                 foreach($headers as $h){
 275                         // verifions le format correct : il faut au moins un ":" dans le header
 276                         // et on filtre le Content-Type: qui sera de toute facon fourni par facteur
 277                         if (strpos($h,":")!==false
 278                           AND strncmp($h,"Content-Type:",13)!==0)
 279                                 $facteur->AddCustomHeader($h);
 280                 }
 281         }
 282
 283         // On passe dans un pipeline pour modifier tout le facteur avant l'envoi
 284         $facteur = pipeline('facteur_pre_envoi', $facteur);
 285
 286         // On génère les headers
 287         $head = $facteur->CreateHeader();
 288
 289         // Et c'est parti on envoie enfin
 290         spip_log("mail via facteur\n$head"."Destinataire:".print_r($destinataire,true),'mail');
 291         spip_log("mail\n$head"."Destinataire:".print_r($destinataire,true),'facteur');
 292         $retour = $facteur->Send();
 293
 294         if (!$retour){
 295                 spip_log("Erreur Envoi mail via Facteur : ".print_r($facteur->ErrorInfo,true),'mail.'._LOG_ERREUR);
 296         }
 297
 298         return $retour ;
 299 }