E-Mail-SMTP-Validator

Question

Ich muss Hunderte von Newslettern versenden, möchte aber zunächst prüfen, ob E-Mails auf dem Server vorhanden sind.Es heißt SMTP Validierung, zumindest glaube ich das, basierend auf meinen Recherchen im Internet.

Es gibt mehrere Bibliotheken, die das können, und auch eine Seite mit Open-Source-Code ASP-Klassiker (http://www.coveryourasp.com/ValidateEmail.asp#Result3), aber es fällt mir schwer, ASP Classic zu lesen, und es scheint, dass es eine Bibliothek eines Drittanbieters verwendet ...

Gibt es Code für die SMTP-Validierung in C# und/oder eine allgemeine Erklärung, wie sie funktioniert?

Answer 1

Beachten Sie, dass bei den meisten MTAs (Mail Transfer Agent) der VRFY-Befehl aus Spam-Schutzgründen deaktiviert ist. Sie werden wahrscheinlich sogar blockiert, wenn Sie mehrere RCPT TO hintereinander versuchen (siehe http://www.spamresource.com/2007/01/whatever-happened-to-vrfy.html).Selbst wenn Sie also eine Bibliothek finden, die diese Überprüfung durchführt, wird es nicht viel wert sein.Ishmaeel hat recht, der einzige Weg, das wirklich herauszufinden, besteht darin, eine E-Mail zu senden und zu sehen, ob sie zurückkommt oder nicht.

@Hrvoje:Ja, ich schlage vor, dass Sie abgelehnte E-Mails überwachen.ABER:Nicht alle zurückgesendeten E-Mails sollten automatisch auf Ihrer „existiert nicht“-Liste landen, Sie müssen auch zwischen temporären (z. B.Postfach voll) und permanente Fehler.

Answer 2

SMTP ist ein textbasiertes Protokoll, das über TCP/IP übertragen wird.

Ihr Validierungsprogramm muss eine TCP/IP-Verbindung zum Port 25 (SMTP) des Servers öffnen, ein paar Zeilen schreiben und die Antwort lesen.Die Validierung erfolgt (jedoch nicht immer) in der Zeile „RCTP TO“ und in der Zeile „VFRY“.

Der SMTP-RFC beschreibt, wie das funktioniert (siehe Green@Beta.ARPA unten, S sind vom Client gesendete Zeilen, R sind vom Server empfangene Zeilen):

Example of the SMTP Procedure

         This SMTP example shows mail sent by Smith at host Alpha.ARPA,
         to Jones, Green, and Brown at host Beta.ARPA.  Here we assume
         that host Alpha contacts host Beta directly.

            S: MAIL FROM:
            R: 250 OK

            S: RCPT TO:
            R: 250 OK

            S: RCPT TO:
            R: 550 No such user here

Answer 3

Obwohl es stimmt, dass viele Domänen aufgrund von Missbrauch falsch positive Ergebnisse zurückgeben, gibt es immer noch einige großartige Komponenten, die über die reine SMTP-Validierung hinaus mehrere Validierungsebenen durchführen.Es lohnt sich zum Beispiel, zunächst zu prüfen, ob die Domain zumindest existiert.Ich bin gerade dabei, meine eigene Liste mit Ressourcen zu dieser Frage zusammenzustellen, die Sie hier verfolgen können:

http://delicious.com/dworthley/email.validation

Für diejenigen, die diese Liste ergänzen möchten, füge ich hier auch das hinzu, was ich derzeit habe:

• aspNetMX
• Klassenbibliothek des .NET-E-Mail-Validierungsassistenten
• MONOProg Email Validator.Net

Für ein kugelsicheres Formular und ein großartiges Benutzererlebnis ist es hilfreich, so viele Aspekte der E-Mail-Adresse wie möglich zu validieren.Ich kann es aus dem sehen aspNetMX Validator, den sie überprüfen:

• die Syntax
• Vergleichen Sie die E-Mail mit einer Liste fehlerhafter E-Mail-Adressen
• Vergleichen Sie die Domain mit einer Liste fehlerhafter Domains
• eine Liste von Postfachdomänen
• ob die Domain existiert oder nicht
• ob MX-Einträge für die Domain vorhanden sind
• und schließlich über SMTP, unabhängig davon, ob ein Postfach vorhanden ist oder nicht

Dieser letzte Schritt kann von Administratoren umgangen werden, indem praktisch bei allen Kontoverifizierungsanfragen „true“ zurückgegeben wird. Wenn der Benutzer jedoch absichtlich eine falsche Adresse eingegeben hat, wird dies in den meisten Fällen bereits erkannt.Und wenn es sich um einen Benutzerfehler im Domänenteil der Adresse handelte, wird dieser ebenfalls abgefangen.

Eine bewährte Methode für die Nutzung eines solchen Dienstes für einen Registrierungsbildschirm oder ein Registrierungsformular wäre natürlich, diese Art der Validierung mit einem Verifizierungsprozess zu kombinieren, um sicherzustellen, dass die E-Mail-Adresse gültig ist.Das Tolle an der Verwendung eines E-Mail-Validators vor einem Verifizierungsprozess ist, dass er insgesamt zu einem besseren Benutzererlebnis führt.

Answer 4

Sie können den folgenden Code ausprobieren, er funktioniert bei mir einwandfrei:

public class EmailTest {
    private static int hear(BufferedReader in) throws IOException {
        String line = null;
        int res = 0;

        while ((line = in.readLine()) != null) {
            String pfx = line.substring(0, 3);
            try {
                res = Integer.parseInt(pfx);
            } catch (Exception ex) {
                res = -1;
            }
            if (line.charAt(3) != '-')
                break;
        }

        return res;
    }

    private static void say(BufferedWriter wr, String text) throws IOException {
        wr.write(text + "\r\n");
        wr.flush();

        return;
    }

    @SuppressWarnings({ "rawtypes", "unchecked" })
    private static ArrayList getMX(String hostName) throws NamingException {
        // Perform a DNS lookup for MX records in the domain
        Hashtable env = new Hashtable();
        env.put("java.naming.factory.initial", "com.sun.jndi.dns.DnsContextFactory");
        DirContext ictx = new InitialDirContext(env);
        Attributes attrs = ictx.getAttributes(hostName, new String[] { "MX" });
        Attribute attr = attrs.get("MX");

        // if we don't have an MX record, try the machine itself
        if ((attr == null) || (attr.size() == 0)) {
            attrs = ictx.getAttributes(hostName, new String[] { "A" });
            attr = attrs.get("A");
            if (attr == null)
                throw new NamingException("No match for name '" + hostName + "'");
        }
        /*
         Huzzah! we have machines to try. Return them as an array list
         NOTE: We SHOULD take the preference into account to be absolutely
         correct. This is left as an exercise for anyone who cares.
         */
        ArrayList res = new ArrayList();
        NamingEnumeration en = attr.getAll();

        while (en.hasMore()) {
            String mailhost;
            String x = (String) en.next();
            String f[] = x.split(" ");
            // THE fix *************
            if (f.length == 1)
                mailhost = f[0];
            else if (f[1].endsWith("."))
                mailhost = f[1].substring(0, (f[1].length() - 1));
            else
                mailhost = f[1];
            // THE fix *************
            res.add(mailhost);
        }
        return res;
    }

    @SuppressWarnings("rawtypes")
    public static boolean isAddressValid(String address) {
        // Find the separator for the domain name
        int pos = address.indexOf('@');

        // If the address does not contain an '@', it's not valid
        if (pos == -1)
            return false;

        // Isolate the domain/machine name and get a list of mail exchangers
        String domain = address.substring(++pos);
        ArrayList mxList = null;
        try {
            mxList = getMX(domain);
        } catch (NamingException ex) {
            return false;
        }

        /*
        Just because we can send mail to the domain, doesn't mean that the
        address is valid, but if we can't, it's a sure sign that it isn't
        */
        if (mxList.size() == 0)
            return false;

        /* 
        Now, do the SMTP validation, try each mail exchanger until we get
        a positive acceptance. It *MAY* be possible for one MX to allow
        a message [store and forwarder for example] and another [like
        the actual mail server] to reject it. This is why we REALLY ought
        to take the preference into account.
        */
        for (int mx = 0; mx < mxList.size(); mx++) {
            boolean valid = false;
            try {
                int res;
                //
                Socket skt = new Socket((String) mxList.get(mx), 25);
                BufferedReader rdr = new BufferedReader(new InputStreamReader(skt.getInputStream()));
                BufferedWriter wtr = new BufferedWriter(new OutputStreamWriter(skt.getOutputStream()));

                res = hear(rdr);
                if (res != 220)
                    throw new Exception("Invalid header");
                say(wtr, "EHLO rgagnon.com");

                res = hear(rdr);
                if (res != 250)
                    throw new Exception("Not ESMTP");

                // validate the sender address
                say(wtr, "MAIL FROM: <tim@orbaker.com>");
                res = hear(rdr);
                if (res != 250)
                    throw new Exception("Sender rejected");

                say(wtr, "RCPT TO: <" + address + ">");
                res = hear(rdr);

                // be polite
                say(wtr, "RSET");
                hear(rdr);
                say(wtr, "QUIT");
                hear(rdr);
                if (res != 250)
                    throw new Exception("Address is not valid!");

                valid = true;
                rdr.close();
                wtr.close();
                skt.close();
            } catch (Exception ex) {
                // Do nothing but try next host
                ex.printStackTrace();
            } finally {
                if (valid)
                    return true;
            }
        }
        return false;
    }

    public static void main(String args[]) {
        String testData[] = { "rahul.saraswat@techblue.com", "rahul.saraswat@techblue.co.uk", "srswt.rahul12345@gmail.com",
        "srswt.rahul@gmail.com" };
        System.out.println(testData.length);
        for (int ctr = 0; ctr < testData.length; ctr++) {
            System.out.println(testData[ctr] + " is valid? " + isAddressValid(testData[ctr]));
        }
        return;
    }
}

Danke und Grüße Rahul Saraswat

Answer 5

Die E-Mail-Validierung von Real(TM) versucht, etwas an die Adresse zu senden und prüft, ob es abgelehnt/zurückgeschickt wird.Sie müssen sie also einfach wegschicken und die fehlgeschlagenen Adressen aus Ihrer Mailingliste entfernen.

Answer 6

Verstehen Sie das nicht falsch, aber das Versenden von Newslettern an mehr als eine Handvoll Menschen ist heutzutage eine ziemlich ernste Angelegenheit.Ja, Sie müssen Bounces (abgelehnte E-Mails) überwachen, die synchron während des SMTP-Versands auftreten können (normalerweise, wenn der SMTP-Server, mit dem Sie verbunden sind, autorisierend ist) oder asynchron als vom System generierte E-Mail-Nachricht, die einige Zeit später auftritt Der SMTP-Versand war erfolgreich.

Beachten Sie auch das CAN-SPAM-Gesetz und halten Sie sich beim Versenden dieser E-Mails an die Gesetze.Sie müssen einen Link zum Abmelden sowie eine physische Adresse angeben (um Sie zu identifizieren und es Benutzern zu ermöglichen, Abmeldeanfragen per Post zu senden, wenn sie dies wünschen).

Wenn Sie diese Dinge nicht tun, kann dies im besten Fall dazu führen, dass Ihre IP auf Null geroutet wird und im schlimmsten Fall verklagt wird.

Answer 7

Möglicherweise benötigen Sie dies E-Mail-Validator-Komponente für .NET

Hier ist das Codebeispiel:

   // Create a new instance of the EmailValidator class.
   EmailValidator em = new EmailValidator();
   em.MessageLogging += em_MessageLogging;
   em.EmailValidated += em_EmailValidationCompleted;
   try
   {
       string[] list = new string[3] { "test1@testdomain.com", "test2@testdomain.com", "test3@testdomain.com" };
       em.ValidateEmails(list);
   }
   catch (EmailValidatorException exc2)
   {
       Console.WriteLine("EmailValidatorException: " + exc2.Message);
   }