Comment tester l’envoi de courriels alors qu’on ne dispose pas d’un serveur mail sur sa plateforme de développement WordPress ?
Une première solution consiste à installer un serveur mail en local, comme je l’ai expliqué dans le cas de WampServer.
Mais parfois, on ne dispose même pas d’une connexion internet. L’extension décrite dans cet article permet de simuler l’envoi de courriels, d’en récupérer le contenu et d’en visualiser les paramètres principaux.

Installer WordPress en local

Pour disposer de WordPress en local, c’est à dire sur un ordinateur personnel, il faut tout d’abord installer un serveur http, une Base de Données et le langage php.

On trouvera un article expliquant comment installer le package WampServer :

https://dfarnier.fr/wamp-installer/

Une fois WampServer installé, il est possible d’installer WordPress :

https://dfarnier.fr/installer-wordpress-sur-wampserver/

À ce moment, on dispose d’un outil de développement permettant de tester les évolutions du site, sans risque, avant de les transférer sur internet.

Parfois les évolutions nécessitent d’envoyer des courriels, or, WampServer ne contient pas de serveur mails. Dans l’article ci-dessous, j’ai expliqué comment installer un tel serveur mail :

https://dfarnier.fr/serveur-mail-wampserver/

Cette solution nécessite une connexion à Internet qui n’est pas toujours disponible. L’article ci-dessous montre comment tester des emails… sans qu’ils soient envoyés via internet.

L’extension décrite permet de visualiser le mail (émetteur, destinataire, contenu) mais aussi de simuler des cas de réussite ou d’échec de l’émission.

Afficher le courriel dans le fichier debug.log

Nous allons afficher son contenu dans le fichier journal (fichier log) en utilisant la fonction php : « error_log()« . Pour une installation WordPress, le fichier journal est appelé « debug.log » et se situe dans le répertoire « wp-content » (même si celui-ci a été déplacé), au même niveau que les répertoires « plugins », « themes »…

Le fichier « debug.log » n’est pas créé par défaut. S’il n’existe pas, il sera créé par la fonction error_log().

Pour que la fonction error_log() écrive dans le fichier « debug.log », deux constantes doivent être positionnées à « true » dans le fichier « wp-config.php » situé par défaut à la racine du site :

define('WP_DEBUG', true);
define('WP_DEBUG_LOG', true);

Utiliser le crochet « phpmailer_init »

La fonction « wp_mail() » de WordPress permet d’envoyer des courriels. Elle se situe dans le ficher « wp-includes/pluggable.php ».

« wp-mail()) » effectue de nombreuses vérifications sur les paramètres du courriel (destinataire, contenu du message, format du message…) et propose plusieurs crochets permettant de paramétrer l’émission.

Nous intervenons au niveau du crochet « phpmailer_init » situé juste avant la phase d’émission du courriel :

Ajouter la fonction personnalisée « wpdf_mail_log »  au crochet « phpmailer_init » :

add_action( 'phpmailer_init', 'wpdf_mail_log');

Écrire le courriel dans le fichier debug.log

Voici la fonction « wpdf_mail_log() » permettant d’écrire le courriel dans le fichier « debug.log » :

function wpdf_mail_log ($wpdf_phpmailer) {
 error_log('================ Début Mail =======================');
 error_log('Emetteur : '.$wpdf_phpmailer->From);
 // Retrouver le destinataire du mail
 $wpdf_mail = print_r($wpdf_phpmailer, true); // récupérer le tableau des destinataires
 $wpdf_patt_to ="#\[to:protected\][^\n]+\n[^\n]+\n[^\n]+\n[^\n]+\n[^>]+> (.*)#";
 preg_match($wpdf_patt_to, $wpdf_mail, $wpdf_mail_to);
 error_log('Destinataire (premier) : '.$wpdf_mail_to[1]);
 error_log('Sujet : '.$wpdf_phpmailer->Subject);
 error_log('Message : '.html_entity_decode($wpdf_phpmailer->Body));
 error_log('================ Fin Mail =======================');
 return ;
} // fin fonction wpdf_mail_log

La variable « $wpdf_phpmailer« , passée à la fonction « wpdf_mail_log() » grâce au crochet « phpmailer_init« ,  contient l’objet « PHPMailer » qui décrit le courriel prêt à être envoyé :

add_action( ‘phpmailer_init‘, ‘wpdf_mail_log‘);
function wpdf_mail_log ($wpdf_phpmailer) {

La fonction php « error_log() » permet d’ajouter une chaîne de caractères dans le fichier log . Nous l’utilisons pour signaler le début du mail :

error_log(‘================ Début Mail =======================’);

Nous y ajoutons ensuite l’émetteur du message qui est contenu dans la propriété « From » de l’objet « $wpdf_phpmailer » :

error_log(‘Emetteur : ‘.$wpdf_phpmailer->From);

Nous ne pouvons pas faire de même pour le destinataire car la propriété « to » est une propriété protégée. Si on tente de l’atteindre directement (« $wpdf_phpmailer->to »), php renvoie une erreur :

PHP Fatal error:  Cannot access protected property PHPMailer::$to

Nous contournons cette difficulté, en appelant la fonction php « print_r()« .
Nous récupérons les propriétés de l’objet « $wpdf_phpmailer » dans une chaîne de caractères en positionnant le deuxième paramètre à « true » :

$wpdf_mail = print_r($wpdf_phpmailer, true);

Nous extrayons l’adresse du premier destinataire  au moyen d’une expression régulière. Voici le « patron » permettant d’isoler cette adresse :

$wpdf_patt_to = »#\[to:protected\][^\n]+\n[^\n]+\n[^\n]+\n[^\n]+\n[^>]+> (.*)# »;
preg_match($wpdf_patt_to, $wpdf_mail, $wpdf_mail_to);

La fonction php « preg_match() » a trois paramètres :

• le patron $wpdf_patt_to : chaîne de caractère codée appelée expression régulière qui permet de repérer et extraire une sous-chaîne (ici l’adresse mail du destinataire) depuis une chaîne « source » (ici le résultat du « print_r() » sur l’objet PHPMailer),
• la chaîne source $wpdf_mail : la chaîne depuis laquelle on va extraire une sous-chaîne  définie par l’expression régulière,
• le tableau de résultat  $wpdf_mail_to : un tableau dont :
  • la première ligne contient la chaîne reconnue conforme à l’expression régulière ,
  • la deuxième ligne contient la sous-chaîne extraite, c’est à dire ce qui correspond à « (.*) » dans le patron.

L’expression régulière commence parla sous-chaîne  marquant le début de la description de la propriété « to » :

#\[to:protected\]

• # : marque le début de l’expression régulière (on le retrouve pour marquer la fin d’expression régulière : « (.*)#»,
• \[ : indique que « [ » correspond au caractère de crochet droit ouvrant, et non un symbole réservé pour coder une expression régulière,
• to:protected : est une chaîne de caractères que nous recherchons,
• \] : indique que « ] » correspond au caractère de crochet droit fermant, et non un symbole réservé pour coder une expression régulière.

Autrement dit, la recherche / extraction dans le corps du message  s’effectuera sur une portion commençant par « [to:protected] ».

Pour mieux comprendre, voici ce qui est retourné par « print_r() » :

La portion d’expression régulière « [^\n]+\n » se décompose en :

• [^\n] : un caractère autre qu’un saut de ligne : « \n » désigne un saut de ligne, « ^ » indique qu’il ne faut pas le caractère qui suit,
• + : au moins un des caractères définis juste avant (donc les caractères qui ne sont pas des sauts de ligne),
• \n : un saut de ligne.

Autrement dit, nous sautons quatre lignes jusqu’à atteindre la définition du destinataire (« [0] => mon_mail@moi.fr »).

La portion d’expression régulière « [^>]+> » indique qu’il faut ensuite sauter tous les caractères jusqu’à atteindre le caractère supérieur « > ». On passe un caractère blanc et on prend les caractères restant sur la ligne ce qui correspond à l’adresse du premier destinataire.
Dans  » (.*) », les parenthèses délimitent la chaîne à extraire, le point représente n’importe quel caractère jusqu’à un saut de ligne et l’étoile indique qu’il faut extraire de zéro à un nombre illimité de caractères.

$wpdf_patt_to ="#\[to:protected\](.*)\[cc:protected\]#s";
preg_match($wpdf_patt_to, $wpdf_mail, $wpdf_mail_to);
error_log(print_r(implode ($wpdf_mail_to), true));

Nous affichons le contenu du courriel, après l’avoir rendu plus lisible en exécutant la fonction « html_entity_decode() » :

error_log(‘Message : ‘.html_entity_decode($wpdf_phpmailer->Body));

Voici le même texte d’un courriel sans, puis avec, la fonction « html_entity_decode() ». On constate que le caractère «   » apparaît d’abord sous forme codée puis pour ce qu’il représente : le caractère blanc :

 Pour configurer votre mot de passe, rendez-vous à l’adresse suivante :
Pour configurer votre mot de passe, rendez-vous à l’adresse suivante :

Voici ce qu’on peut lire dans le fichier « debug.log » pour des courriels créés lors de l’inscription d’un nouvel utilisateur :

[20-Mar-2016 09:30:42 UTC] ================ Début Mail =======================
[20-Mar-2016 09:30:42 UTC] Emetteur : wordpress@localhost
[20-Mar-2016 09:30:42 UTC] Destinataire (premier) : admin@adminwp.fr
[20-Mar-2016 09:30:42 UTC] Sujet : [Site local de test] Inscription d’un nouvel utilisateur
[20-Mar-2016 09:30:42 UTC] Message : Inscription d’un nouvel utilisateur sur votre site Site local de test :

Identifiant : moi

E-mail : mon_mail@moi.fr

[20-Mar-2016 09:30:42 UTC] ================ Fin Mail =======================
[20-Mar-2016 09:30:42 UTC] ================ Début Mail =======================
[20-Mar-2016 09:30:42 UTC] Emetteur : wordpress@localhost
[20-Mar-2016 09:30:42 UTC] Destinataire (premier) : mon_mail@moi.fr
[20-Mar-2016 09:30:42 UTC] Sujet : [Site local de test] Votre identifiant et votre mot de passe
[20-Mar-2016 09:30:42 UTC] Message : Identifiant : moi

Pour configurer votre mot de passe, rendez-vous à l’adresse suivante :

<http://localhost/demo/coucou?action=rp&key=4yKMFJAtA9y5s9JgghyD&login=moi>

http://localhost/demo/coucou

[20-Mar-2016 09:30:42 UTC] ================ Fin Mail =======================

Retourner un statut choisi après « émission » du courriel

L’objectif étant de disposer d’un outil de développement, nous avons besoin de tester les cas d’émission réussie comme les cas d’émission ayant échouée. Par exemple, la procédure d’envoi de courriel pour modification du mot de passe affiche le message suivant s’il détecte que l’envoi a échoué :

Le programme standard d’émission de courriel de WordPress ne propose pas de crochet permettant de modifier le statut après la tentative d’émission :

Heureusement, la fonction wp_mail() est une fonction redéfinissable (pluggable) c’est à dire qu’on peut réaliser sa propre version qui sera exécutée à la place de la fonction standard.

Les fonctions redéfinissables se trouvent dans le fichier : « wp-includes\pluggable.php ». Elles commencent par un test d’existence :

if ( !function_exists( ‘wp_mail’ ) ) :

Nous recopions la totalité de la fonction « wp_mail() » dans le fichier de l’extension, nous la renommons en « wpdf_wp_mail() » et nous créons une nouvelle fonction « wp_mail » :

function wp_mail( $wpdf_to, $wpdf_subject, $wpdf_message, $wpdf_headers = '', $wpdf_attachments = array() ) {
 $wpdf_retour = wpdf_wp_mail( $wpdf_to, $wpdf_subject, $wpdf_message, $wpdf_headers = '', $wpdf_attachments = array() );

 // choisir son statut de retour
 return $wpdf_retour;
 //return true; 
 //return false;
} // fin fonction wp_mail redéfinie

Cette nouvelle fonction « wp_mail » réalise deux choses :

• appeler la fonction « wpdf_wp_mail() » qui est le clone de la fonction « wp_mail() » standard de WordPress,
• renvoyer la valeur de retour réelle ou choisie :
  • la valeur retournée par la fonction qui a envoyé le mail : « wpdf_wp_mail() »,
  • « true » : comme si l’émission s’était passée correctement,
  • « false » : comme si l’émission n’avait pu être réalisée.

La valeur retournée est la première qui n’est pas indiquée comme étant un commentaire, c’est à dire celle qui ne commence pas par deux barres verticales (« // »).

Remarques sur l’utilisation des fonctions redéfinissables

Nous aurions pu totalement redéfinir la fonction « wp_mail() », par exemple en recopiant simplement dans le fichier journal ses paramètres : $to, $subject, $message, $headers, $attachments.

Ceci fonctionne correctement, mais ne permet pas de tester en profondeur l’émission de courriels :

• les vérifications effectuées dans « wp_mail() » ne sont pas réalisées (exemple : vérifier qu’une adresse mail soit correcte),
• les valeurs par défaut ne sont pas gérées (exemple : l’émetteur par défaut est « wordpress@nom_de_domaine_du site »),
• les crochets ne son t pas pris en compte (exemple : le filtre « wp_mail_from » permet de modifier l’adresse mail de l’expéditeur).

Les fonctions redéfinissables permettent de remplacer certaines fonctions fournies par WordPress. Il faut simplement se souvenir qu’il convient de remplacer non seulement le principal fonctionnement mais aussi tout ce qui enrichit la fonction : vérifications, valeurs par défaut et crochets.

Le code de l’extension

<?php
/*
Plugin Name: simule l'envoi d'un courriel
Description: recopie le paramétrage d'un courriel dans le fichier journal (debug.log)
Version: 1.0
Plugin URI: http://dfarnier.fr/simuler-serveur-mail/
Author: Daniel Farnier
License: GPL v2 or later


Copyright 2016 - Daniel Farnier (daniel@dfarnier.fr)

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
*/

if ( !defined('ABSPATH') ) exit ('Faites demi-tour !'); // Bloquer si la fonction n'est pas appelée depuis Wordpress


/**
 *	affichage des courriels dans le fichier journal (debug.log)
 *
 *	Redéfinit la fonction wp_mail qui est redéfinissable (pluggable)
 *
 *	Permet de renvoyer un statut à vrai ou à faux
*/

function wp_mail( $wpdf_to, $wpdf_subject, $wpdf_message, $wpdf_headers = '', $wpdf_attachments = array() ) {
	$wpdf_retour = wpdf_wp_mail( $wpdf_to, $wpdf_subject, $wpdf_message, $wpdf_headers = '', $wpdf_attachments = array() );

	//	choisir son statut de retour
	return $wpdf_retour;
	//return true;	
	//return false;
}	//	fin fonction wp_mail redéfinie

/**
 *
 *	Affiche le mail dans le fichier log
 *
 *	Utiise le crochet php_mailer_init pour afficher le contenu du mail dans le fichier log
 *
*/

add_action( 'phpmailer_init', 'wpdf_mail_log');

function wpdf_mail_log ($wpdf_phpmailer) {
	error_log('================ Début Mail  =======================');
	error_log('Emetteur : '.$wpdf_phpmailer->From);
	//	Retrouver le destinataire du mail
	$wpdf_mail = print_r($wpdf_phpmailer, true);	//	récupérer le tableau des destinataires
	$wpdf_patt_to ="#\[to:protected\][^\n]+\n[^\n]+\n[^\n]+\n[^\n]+\n[^>]+> (.*)#";
	preg_match($wpdf_patt_to, $wpdf_mail, $wpdf_mail_to);
	error_log('Destinataire (premier) : '.$wpdf_mail_to[1]);
	error_log('Sujet : '.$wpdf_phpmailer->Subject);
	error_log('Message : '.$wpdf_phpmailer->Body);
	error_log('Message : '.html_entity_decode($wpdf_phpmailer->Body));
	error_log('================ Fin Mail  =======================');
	return ;
}	//	 fin fonction wpdf_mail_log


/**
 * Recopie de la fonction wp_mail() standard
 *
 *
 */
 
function wpdf_wp_mail( $to, $subject, $message, $headers = '', $attachments = array() ) {

	
	// Compact the input, apply the filters, and extract them back out

	/**
	 * Filter the wp_mail() arguments.
	 *
	 * @since 2.2.0
	 *
	 * @param array $args A compacted array of wp_mail() arguments, including the "to" email,
	 *                    subject, message, headers, and attachments values.
	 */
	$atts = apply_filters( 'wp_mail', compact( 'to', 'subject', 'message', 'headers', 'attachments' ) );

	if ( isset( $atts['to'] ) ) {
		$to = $atts['to'];
	}

	if ( isset( $atts['subject'] ) ) {
		$subject = $atts['subject'];
	}

	if ( isset( $atts['message'] ) ) {
		$message = $atts['message'];
	}

	if ( isset( $atts['headers'] ) ) {
		$headers = $atts['headers'];
	}

	if ( isset( $atts['attachments'] ) ) {
		$attachments = $atts['attachments'];
	}

	if ( ! is_array( $attachments ) ) {
		$attachments = explode( "\n", str_replace( "\r\n", "\n", $attachments ) );
	}
	global $phpmailer;

	// (Re)create it, if it's gone missing
	if ( ! ( $phpmailer instanceof PHPMailer ) ) {
		require_once ABSPATH . WPINC . '/class-phpmailer.php';
		require_once ABSPATH . WPINC . '/class-smtp.php';
		$phpmailer = new PHPMailer( true );
	}

	// Headers
	if ( empty( $headers ) ) {
		$headers = array();
	} else {
		if ( !is_array( $headers ) ) {
			// Explode the headers out, so this function can take both
			// string headers and an array of headers.
			$tempheaders = explode( "\n", str_replace( "\r\n", "\n", $headers ) );
		} else {
			$tempheaders = $headers;
		}
		$headers = array();
		$cc = array();
		$bcc = array();

		// If it's actually got contents
		if ( !empty( $tempheaders ) ) {
			// Iterate through the raw headers
			foreach ( (array) $tempheaders as $header ) {
				if ( strpos($header, ':') === false ) {
					if ( false !== stripos( $header, 'boundary=' ) ) {
						$parts = preg_split('/boundary=/i', trim( $header ) );
						$boundary = trim( str_replace( array( "'", '"' ), '', $parts[1] ) );
					}
					continue;
				}
				// Explode them out
				list( $name, $content ) = explode( ':', trim( $header ), 2 );

				// Cleanup crew
				$name    = trim( $name    );
				$content = trim( $content );

				switch ( strtolower( $name ) ) {
					// Mainly for legacy -- process a From: header if it's there
					case 'from':
						$bracket_pos = strpos( $content, '<' );
						if ( $bracket_pos !== false ) {
							// Text before the bracketed email is the "From" name.
							if ( $bracket_pos > 0 ) {
								$from_name = substr( $content, 0, $bracket_pos - 1 );
								$from_name = str_replace( '"', '', $from_name );
								$from_name = trim( $from_name );
							}

							$from_email = substr( $content, $bracket_pos + 1 );
							$from_email = str_replace( '>', '', $from_email );
							$from_email = trim( $from_email );

						// Avoid setting an empty $from_email.
						} elseif ( '' !== trim( $content ) ) {
							$from_email = trim( $content );
						}
						break;
					case 'content-type':
						if ( strpos( $content, ';' ) !== false ) {
							list( $type, $charset_content ) = explode( ';', $content );
							$content_type = trim( $type );
							if ( false !== stripos( $charset_content, 'charset=' ) ) {
								$charset = trim( str_replace( array( 'charset=', '"' ), '', $charset_content ) );
							} elseif ( false !== stripos( $charset_content, 'boundary=' ) ) {
								$boundary = trim( str_replace( array( 'BOUNDARY=', 'boundary=', '"' ), '', $charset_content ) );
								$charset = '';
							}

						// Avoid setting an empty $content_type.
						} elseif ( '' !== trim( $content ) ) {
							$content_type = trim( $content );
						}
						break;
					case 'cc':
						$cc = array_merge( (array) $cc, explode( ',', $content ) );
						break;
					case 'bcc':
						$bcc = array_merge( (array) $bcc, explode( ',', $content ) );
						break;
					default:
						// Add it to our grand headers array
						$headers[trim( $name )] = trim( $content );
						break;
				}
			}
		}
	}

	// Empty out the values that may be set
	$phpmailer->ClearAllRecipients();
	$phpmailer->ClearAttachments();
	$phpmailer->ClearCustomHeaders();
	$phpmailer->ClearReplyTos();

	// From email and name
	// If we don't have a name from the input headers
	if ( !isset( $from_name ) )
		$from_name = 'WordPress';

	/* If we don't have an email from the input headers default to wordpress@$sitename
	 * Some hosts will block outgoing mail from this address if it doesn't exist but
	 * there's no easy alternative. Defaulting to admin_email might appear to be another
	 * option but some hosts may refuse to relay mail from an unknown domain. See
	 * https://core.trac.wordpress.org/ticket/5007.
	 */

	if ( !isset( $from_email ) ) {
		// Get the site domain and get rid of www.
		$sitename = strtolower( $_SERVER['SERVER_NAME'] );
		if ( substr( $sitename, 0, 4 ) == 'www.' ) {
			$sitename = substr( $sitename, 4 );
		}

		$from_email = 'wordpress@' . $sitename;
	}

	/**
	 * Filter the email address to send from.
	 *
	 * @since 2.2.0
	 *
	 * @param string $from_email Email address to send from.
	 */
	$phpmailer->From = apply_filters( 'wp_mail_from', $from_email );

	/**
	 * Filter the name to associate with the "from" email address.
	 *
	 * @since 2.3.0
	 *
	 * @param string $from_name Name associated with the "from" email address.
	 */
	$phpmailer->FromName = apply_filters( 'wp_mail_from_name', $from_name );

	// Set destination addresses
	if ( !is_array( $to ) )
		$to = explode( ',', $to );

	foreach ( (array) $to as $recipient ) {
		try {
			// Break $recipient into name and address parts if in the format "Foo <bar@baz.com>"
			$recipient_name = '';
			if ( preg_match( '/(.*)<(.+)>/', $recipient, $matches ) ) {
				if ( count( $matches ) == 3 ) {
					$recipient_name = $matches[1];
					$recipient = $matches[2];
				}
			}
			$phpmailer->AddAddress( $recipient, $recipient_name);
		} catch ( phpmailerException $e ) {
			continue;
		}
	}

	// Set mail's subject and body
	$phpmailer->Subject = $subject;
	$phpmailer->Body    = $message;

	// Add any CC and BCC recipients
	if ( !empty( $cc ) ) {
		foreach ( (array) $cc as $recipient ) {
			try {
				// Break $recipient into name and address parts if in the format "Foo <bar@baz.com>"
				$recipient_name = '';
				if ( preg_match( '/(.*)<(.+)>/', $recipient, $matches ) ) {
					if ( count( $matches ) == 3 ) {
						$recipient_name = $matches[1];
						$recipient = $matches[2];
					}
				}
				$phpmailer->AddCc( $recipient, $recipient_name );
			} catch ( phpmailerException $e ) {
				continue;
			}
		}
	}

	if ( !empty( $bcc ) ) {
		foreach ( (array) $bcc as $recipient) {
			try {
				// Break $recipient into name and address parts if in the format "Foo <bar@baz.com>"
				$recipient_name = '';
				if ( preg_match( '/(.*)<(.+)>/', $recipient, $matches ) ) {
					if ( count( $matches ) == 3 ) {
						$recipient_name = $matches[1];
						$recipient = $matches[2];
					}
				}
				$phpmailer->AddBcc( $recipient, $recipient_name );
			} catch ( phpmailerException $e ) {
				continue;
			}
		}
	}

	// Set to use PHP's mail()
	$phpmailer->IsMail();

	// Set Content-Type and charset
	// If we don't have a content-type from the input headers
	if ( !isset( $content_type ) )
		$content_type = 'text/plain';

	/**
	 * Filter the wp_mail() content type.
	 *
	 * @since 2.3.0
	 *
	 * @param string $content_type Default wp_mail() content type.
	 */
	$content_type = apply_filters( 'wp_mail_content_type', $content_type );

	$phpmailer->ContentType = $content_type;

	// Set whether it's plaintext, depending on $content_type
	if ( 'text/html' == $content_type )
		$phpmailer->IsHTML( true );

	// If we don't have a charset from the input headers
	if ( !isset( $charset ) )
		$charset = get_bloginfo( 'charset' );

	// Set the content-type and charset

	/**
	 * Filter the default wp_mail() charset.
	 *
	 * @since 2.3.0
	 *
	 * @param string $charset Default email charset.
	 */
	$phpmailer->CharSet = apply_filters( 'wp_mail_charset', $charset );

	// Set custom headers
	if ( !empty( $headers ) ) {
		foreach ( (array) $headers as $name => $content ) {
			$phpmailer->AddCustomHeader( sprintf( '%1$s: %2$s', $name, $content ) );
		}

		if ( false !== stripos( $content_type, 'multipart' ) && ! empty($boundary) )
			$phpmailer->AddCustomHeader( sprintf( "Content-Type: %s;\n\t boundary=\"%s\"", $content_type, $boundary ) );
	}

	if ( !empty( $attachments ) ) {
		foreach ( $attachments as $attachment ) {
			try {
				$phpmailer->AddAttachment($attachment);
			} catch ( phpmailerException $e ) {
				continue;
			}
		}
	}

	/**
	 * Fires after PHPMailer is initialized.
	 *
	 * @since 2.2.0
	 *
	 * @param PHPMailer &$phpmailer The PHPMailer instance, passed by reference.
	 */
	do_action_ref_array( 'phpmailer_init', array( &$phpmailer ) );

	// Send!
	try {
		return $phpmailer->Send();
	} catch ( phpmailerException $e ) {

		$mail_error_data = compact( $to, $subject, $message, $headers, $attachments );

		/**
		 * Fires after a phpmailerException is caught.
		 *
		 * @since 4.4.0
		 *
		 * @param WP_Error $error A WP_Error object with the phpmailerException code, message, and an array
		 *                        containing the mail recipient, subject, message, headers, and attachments.
		 */ 

 		do_action( 'wp_mail_failed', new WP_Error( $e->getCode(), $e->getMessage(), $mail_error_data ) );
		return false;
	}
}

?>

On trouve dans l’article Modifier l’accès à wp-login.php la façon de récupérer le code pour ajouter l’extension sur son site .