Envoi emails (SMPT_SEND)

Bonjour,
Je cherche à envoyer des emails a des destinataires sélectionnés dans une data base.
Le code :

SMTP_New ($SMTPid)
$Maildest:=[Adhe]Email
$Locfail:=SMTP_SetPrefs (-1;5;-1)
$Locfail:=SMTP_Charset (1;1)
$Locfail:=SMTP_Host ($SMTPid;Mailserver;0)
$Locfail:=SMTP_From ($SMTPid;Mailuser;0)
$Locfail:=SMTP_Cc ($SMTPid;$MailCC)
$Locfail:=SMTP_Bcc ($SMTPid;$MailCCI;0)
S$Locfail:=SMTP_Subject ($SMTPid;$Mailsujet;0)
S$Locfail:=SMTP_Body ($SMTPid;$Mailtext;4)
S$Locfail:=SMTP_Auth ($SMTPid;Mailuser;MailPwd;0)
CHERCHER([Adhe]Status:=“A jour”
Tant que (OK=1)
Si ([Adhe]Email#"")
$Maildest:=[Adhe]Email
$Locfail:=SMTP_To ($SMTPid;$Maildest)
Fin de si
ENREGISTREMENT PRÉCEDENT([Adhe])
Fin tant que
Locfail:=0
$Locfail:=SMTP_Send ($SMTPid;1)
SMTP_Clear ($SMTPid)

Ca ne marche pas les emails n’arrivent pas.
Code erreur $Locfail=0 ou 10039 5smpt 550°

Je pense que c’est le webserver de Free qui plante, à moins qu’il n’y ait y une erreur.Si oui laquelle.
Merci de votre retour.

Bojour

Je n’ai aucun problème avec le serveur smtp de free, sans authentification, à condition que le fournisseur d’accès soit bien free. (en dehors du réseau free, en wifi en déplacemet par exemple, c’est une autre histoire)

je te suggère de faire un test avec un bout de code plus simple.

Chez moi, ce code fonctionne :

<code 4D>
$vt_from:="olivier@drut.fr"
$vt_to:="marseille@drut.fr"

$Locfail:=SMTP_New ($SMTPid)
$Locfail:=SMTP_Host ($SMTPid;“smtp.free.fr”)
$Locfail:=SMTP_From ($SMTPid;$vt_from)
$Locfail:=SMTP_Subject ($SMTPid;“test subject”)
$Locfail:=SMTP_Body ($SMTPid;“test body”)

$Locfail:=SMTP_To ($SMTPid;$vt_to)
$Locfail:=SMTP_Send ($SMTPid;1)
$err:=SMTP_Clear ($SMTPid)

</code 4D>

Olivier,
Mon code comme le tien marche, mais quelques destinataires.

La séquence suivante marche également
$Maildest:="bb.yy@toto.fr; xx.yy@toto.fr; XXXXXX" //avec 22 destinataires marche. je l’ai testé…
$Locfail:=SMTP_To ($SMTPid;$Maildest)
$Locfail:=SMTP_Send ($SMTPid;1)
SMTP_Clear ($SMTPid)

Mais la différence est que l’affectation du destinataire se fait dans une boucle de la façon suivante :
Boucle
$Maildest:=[Adhe]Email
$Locfail:=SMTP_To ($SMTPid;$Maildest;0)
Suivant
Fin de boucle
// avec le dernier paramètre = 0 ou omis ce qui ajoute le destinataire à la liste déjà fournie. Avec cette instruction le nombre de destinataires augmente à chaque boucle.

La séquence suivante ne marche pas non plus
$Maildest:=[Adhe]Email
Destinataire suivant
Boucle
$Maildest:=$Maildest+"; "+[Adhe]Email
Destinataire suivant
Fin de boucle
$Locfail:=SMTP_To ($SMTPid;$Maildest;1) // avec 1 comme param qui remplace la liste éventuellement existante par la valeur de $Maildest
$Locfail:=SMTP_Send ($SMTPid;1)
SMTP_Clear ($SMTPid)

En tous cas merci de ton aide.

quand je cherche le code d’erreur 550, la réponse devient évidente:

https://support.google.com/a/answer/3726730?hl=frhttps://support.google.com/a/answer/3726730?hl=fr>

le problème est peut-être effectivement dans $Maildest, il suffit d’une adresse email mal formatée.

(au passage, ne vaut-il pas mieux passer les adresses en bcc pour éviter que tous les destinataires reçoivent les adresses en clair ? )

Olivier,
Tu écris
“Je n’ai aucun problème avec le serveur smtp de free, sans authentification, à condition que le fournisseur d’accès soit bien free. (en dehors du réseau free, en wifi en déplacemet par exemple, c’est une autre histoire)”

Il est vrai que chez moi sur suis yahoo. ET que j’envoie ces requêttes au serveur free de l’assos… VU ce que tu écris cela pourrai venir de là.
Je testerai à L’assos directement sur le réseau free.
Je transmets le résultat des courses dès que je l’ai.

: Bruno COGRANNE

Il est vrai que chez moi sur suis yahoo.
Yahoo n’est pas un fournisseur d’accès à internet

Bernard.
Sorry je suis sur Orange ;+)
550, “5.4.5”, La limite quotidienne du relais SMTP a été atteinte pour le compte utilisateur. Pour plus d’informations sur les limites du relais SMTP, veuillez contacter votre administrateur ou consulter cet article.
mais si j’envoie des emails ensuite ils passent sans problème… Donc la limitation quotidienne ??
Peut plus le nombre de destinataire dans un envoi (pour éviter les spam ?).

Olivier,
Les adresses en Bcc donnent le même résultat

Comme le dit soub yahoo n’est pas un fournisseur d’accès.

Mais si chez toi tu n’es pas chez free tu as 2 options :

  • soit tu utilises le smtp de ton fournisseur d’accès chez toi (Orange, free, sfr, Bouygues, etc… )

  • soit tu autorises l’utilisation du SMTP authentifié pour l’adresse free de ton asso. Dans ce cas tu pourras envoyer des emails de partout en utilisant le compte free de l’asso. Tu vas sur ton compte free, l’onglet “gérer mes emails” en bas de page, puis “gérer mon compte” et enfin “Gestion du SMTP authentifié”

: Bruno COGRANNE

Peut plus le nombre de destinataire dans un envoi (pour éviter les
spam ?).

Peut-être en effet. Chaque serveur smtp a ses petites manies, il faut tester et composer en fonction. De toute façon mieux vaut éviter les gros envois pour ne pas se faire étiqueter “spammer” par le serveur smtp.

Sauf à ce qu’il soit fou, AUCUN serveur d’envoi de mail (digne de ce nom) n’envoie plus de mail si vous n’êtes pas dûment authentifié sous peine d’être blacklisté lui-même directement (on ne fait plus du relay depuis longtemps).

Pour s’authentifier auprès de son serveur de mail, il y a plusieurs possibilités.

Soit, vous êtes sur la ligne de votre fournisseur d’accès, dans ce cas quasiment TOUS se réserve le port 25 pour l’envoi de mail SMTP. Soit ,vous êtes en déplacement, il FAUT utiliser le port 587 et TRÈS certainement s’authentifier auprès du serveur de mail d’envoi.

Après, peut encore se rajouter des quotas d’envoi en fonction de votre contrat.
Il peut y avoir également des limitations dans le nombre de destinataires, etc.

En fonction du prestataire du serveur d’envoi, il peut y avoir des spécificités ; par exemple, les serveurs Gmail ont des protections qui empêchent l’envoi de mail par une autre application, il faut dans ce cas désactiver ces protections spécifiques.

Un conseil : si vous voulez faire des mailings ne le faites pas vous-même, passer par des sociétés spécialisées qui savent le faire correctement sous peine de vous retrouver rapidement blacklisté partout, c’est alors que les problèmes commencent.

J’apporte ma pierre à l’édifice…

En effet, les prestataires d’internet mette des quotas, filtrent parfois des PJ, etc : le résultat est imprévisible et très galère.
Donc, pour une utilisation pro, il faut la jouer pro en passant par des prestataires dédiés, comme des services de smtp, justement. Ca permet d’envoyer un peu ce que l’on veut, mais avec une autre contrainte : gérer les retours que fournit le prestataire dans des logs et qui indique plusieurs choses, les soft bounce et les hard bounce.
Votre email doit aussi contenir un lien de désinscription, ou le prestataire l’ajoute automatiquement, et à vous de gérer idem les demandes.

Il faut aussi bien sûr éviter les emails mal formés dès le départ, ils aiment pas du tout.
Car tout cela est là pour éviter que vous soyez un gros spammer, et ils le vérifient en regardant que vous n’avez pas plus de 0,1 % de retour (selon les prestataires). Et aussi que vous ne renvoyez pas des emails déjà listé en soft ou hard bounce trop de fois. Bref, vous devez nettoyer vos listings d’emails !

Moi j’utilise https://www.smtp2go.com/smtp2go> avec un forfait à 14$ par mois, et 20 000 emails.
C’est très raisonnable.

Après à chaque emailing, je reçois un email qui liste les retours. A vous d’agir “à la main” ou alors de vous sentir de retrousser vos manches et d’utiliser les API pour le faire automatiquement…

Leur hotline est très efficace et rapide.
Voilàààà je suis un bon parrain :slight_smile:

Et ma méthode pour détecter qu’un email est valide, déjà le premier pas :

<code 4D>
C_TEXT($regex)
$regex:="[a-z0-9._%±]+@(?:[a-z0-9-]+\.)+[a-z]{2,6}"
$isFormatOk:=Match regex($regex;Lowercase($email))

</code 4D>

Ne pas oublier la syntaxe d’un email qui peut être “nom prénom blabla myemail@myDomain.com”.
Il faut tester si on a <> et extraire l’email pour le vérifier.

Idem, un email peut en comporter plusieurs adresses, séparés par des “,” ou des “;”, ce dernier étant le plus “officiel”.
Il faut donc faire un split de la string en autant de sous-strings. Et les traiter séparément.
Pour ma part, je teste au début s’il y a une “,” ou un “;”, et je splite en considérant que dans un email donné, le séparateur est le même !

<code 4D>

// ----------------------------------------------------
// Method : v_email_check
// Description
// Check if format (and format only) is a valid email (possibly multiples emails).
//
// Parameters
// $1 => Email to check
// $0 <= true / false
// ----------------------------------------------------

C_TEXT($email)
$email:=$1

C_BOOLEAN($isOk)
$isOk:=False

v_Rub_MSpaces (->$email)
ARRAY TEXT($T_Email;0)

If ($email#"")
C_TEXT($sep_multimail)
Case of
: (Position(",";$email)>0)
$sep_multimail:=","

	: (Position(";";$email)>0)
		$sep_multimail:=";"
	Else 
		$sep_multimail:=";"
End case 

C_LONGINT($nb;$i;$k)
C_BOOLEAN($isFormatOk)
v_splitVal ($email;$sep_multimail;->$T_Email)
$nb:=Size of array($T_Email)

If ($nb>0)
	C_TEXT($regex)
	$regex:="[a-z0-9._%+-]+@(?:[a-z0-9-]+\\.)+[a-z]{2,6}"
	$isOk:=True
	For ($i;1;$nb)
		$email:=$T_Email{$i}
		$k:=Position("<";$email)
		If ($k>0)
			If (Substring($email;Length($email);1)=">")
				$email:=Substring($email;$k+1;Length($email)-$k-1)
			End if 
		End if 
		$isFormatOk:=Match regex($regex;Lowercase($email))
		If ($isFormatOk=False)
			$isOk:=False
			$i:=$nb
		End if 
	End for 
End if 

End if

$0:=$isOk

</code 4D>

v_Rub_MSpaces removes spaces before and after…

v_splitVal :
<code 4D>
//$1 = Valeur [TEXTE]
//$2 = caractère de séparation
//$3 = pointeur vers tableau de résultats

C_LONGINT($iCount;$i;$j)
C_TEXT($tmp)

$iCount:=Length($1)
$j:=Position($2;$1;1)

$i:=1
While ($j>0)
$tmp:=Substring($1;$i;$j-$i)
$tmp:=v_trim ($tmp)
APPEND TO ARRAY($3->;$tmp)

$i:=$j+1
$j:=Position($2;$1;$i)

End while

$tmp:=Substring($1;$i;$iCount-$i+1)
$tmp:=v_trim ($tmp)
APPEND TO ARRAY($3->;$tmp)

</code 4D>

v_trim is same as v_Rub_MSpaces, but works on value rather than pointer.