[D2009] Online eMail-Adress Prüfung obs valide ist?

[KodeZwerg]

Delphi-Version: Delphi 2009

Hallo,
mit Delphis Online Komponenten bin ich Neuling und ich benötige für einen Registrier-Dialog eine Prüfung ob eingegebene eMail Adresse tatsächlich existiert.
Ich möchte keine eMail dahin versenden, nur online Prüfen ob das Ziel valide ist.
Mein Delphi hat momentan keine Dritthersteller Tools, aber auf Platte schlummert noch ICS falls das helfen kann dabei.

So etwas wünsche ich mir / pseudo-Code:

Delphi-Quellcode:

if CheckEmailAddresse('[e-mail]') = True then .....

Hätte jemand für solchen Zweck eventuell etwas was mir dabei helfen kann dies zu realisieren?

Später würde ich gerne meine App erweitern mit der Möglichkeit ein eMail Formular an mich selbst zu versenden. Support-Features.

Mein momentaner Applikation Status = es sind noch gar keine Online Dinge integriert.

Ps: DP Suche und CodeLib haben bei mir zu keinem Resultat geführt.

[jobo]

Vielleicht hilft das:
http://www.howtodothings.com/compute...in-delphi.html

Mal zu Deiner Fußzeile:
Erwartete Fehler sind die, die bekanntermaßen auftreten können. Z.B. datei speichern, Speicherplatz unzureichend. Oder früher mal unter Delphi(?), Fehler "nicht genügend Speicherplatz" erwartet> verfügbare Größe abgefragt, Werteüberlauf wegen riesiger freier Festplatte, auch ein "erwartbarer" Fehler, zumindest beim 2.Mal, umgerechnet, genug Platz frei, also speichern.

Im Prinzip finde ich diese Frage auch spannend. Aber ich würde sagen, das ist eigentlich alltägliche Arbeit eines Programmierers.

[MEissing]

Man muss hier zwei Dinge unterschieden:
- Syntaktische Richtigkeit ([e-mail]) und
- inhaltliche Korrektheit

Ersteres ist am besten über PCRE (Regular Expressions) möglich:
Man sollte aber auch bedenken, daß das nicht die ganze Wahrheit ist!
https://davidcel.is/posts/stop-valid...es-with-regex/
(Tl'dr:MIt RegEx kann man auch nicht alle gültigen eMail Adressen finden)

Zweitens ist unmöglich. Es gib kein zentrales Verzeichnis alles eMail Adressen. Und die meisten eMail-Server reagieren auf "Gültigkeitsanfragen" jedweder Art nicht.

[KodeZwerg]

Danke jobo & MEissing, ich habe Eure Links gecheckt, da geht es aber nicht um eine Online-Prüfung, nur ob Input einer Norm entspricht.

Meine Fußzeile bedarf zwar keiner Antwort, ich finde es manchmal einfach nur lustig was Windows so von sich gibt :stupid:


Meine Theorie, da ich Neuling bin ist das bestimmt falsch, wäre es so in etwa umzusetzen:
1. DNS abfrage ob Domain existiert
2. SMTP abfrage ob Domain überhaupt diesen Service anbietet
3. auf eben diesen Server connecten
4. “RCPT TO” Kommando darauf loslassen
5. Auswerten was der Server von sich gibt

Mir fehlt das Basiswissen zu allen Punkten.

[jobo]

Ja, kann man machen.
Allererster Schritt vor irgendeiner Online Aktion aus einem Programm heraus, das sowas noch nie gemacht hat, wäre m.E. sicherzustellen, dass das (eigene) Programm selbst online ist und die benötigten Kanäle (Ports) nach draußen frei sind.
"Ja, klar, natürlich bin ich selber online, ist doch selbstverständlich..."
Na vielleicht nicht, und wenn Du es nicht bist, was ist dann mit der Prüfung der Adressen? Der Mechnismus müsste dann queuen oder das Programm selbst müsste "online" laufen, dann wäre die Hürde schon mal genommen. (Ist aber bei einem nativen Delphiprogramm nicht die Regel-sagen wir mal) oder Du schaltest intelligent auf einen Offline Fallback um.

Am Ende kann man diesen Kram doch wohl am wirkungsvollsten behandeln, indem man Emails mit "Callback" Links verschickt, wie man es von Registrierung und Co kennt.

[Schokohase]

Informiere dich darüber, wie (viele) Mail-Server sich aktuell vor Spam-Schleudern schützen. Das sollte für eine Erkenntnis und Abwägung soweit erstmal genügen.

[KodeZwerg]

Callback / Junk-Schutz wollte ich einbauen nachdem meine Theorie durch ist. Danke definitiv für diese Guten Worte/Hinweise !


Dann mach ich mich mal auf die Suche wie ich meine Theorie in Delphi-Code verwandel, als Quick-Test sozusagen, für eine reelle Prüfung habe ich später vorgehabt so etwas in der Art umzusetzen:
Reelle Theorie:
1. Sende tatsächlich eine eMail
2. Werte SMTP Ergebnis aus ob Server eMail ablehnt
3. warte bis zu 24Std auf Reaktion von Server (also eigenes Konto abrufen ob ein Senden-Fehlerbericht vorliegt)

Oder eben generell nur auf "ich sende eMail, schreibt Empfänger nicht zurück dann war es Mist."
Wie ich so etwas automatisieren kann muss ich mir noch aneignen, das trifft auch auf Punkt 3 zu.

[Delphi.Narium]

DNS-Abfreage kann schonmal ein Ansatz sein.

Schau bitte mal hier: https://www.qualidator.com/WQM/de/Tools/DNSReport.aspx

Dort gib' die Domain Deiner Wahl ein.

Du erhältst ggfls. Infos zu den von der Domain "vorgehaltenen" Servern, wie z. B. Nameserver, SMPTServer ...

Bei den Indys gibt's tIdDNSResolver, damit kann man die entsprechenden Infos auch selber abfragen. ICS sollte sowas auch bieten (tDnsQuery).

Und die Infos jetzt an Tante Google: delphi source IdDNSResolver oder delphi source DnsQuery

Damit sollte dann ein Anfang möglich sein. (Und wie fast schon üblich, wird man damit hier in der Delphipraxis fündig :-))

https://www.delphipraxis.net/102950-...indy-10-a.html

Automatisieren lässt sich das mit Delphi sicherlich.

Zuerst mal DNS-Abfrage.
Gibt's die Domain?
Hat sie 'nen Mailserver (MX-Record)?
Dann 'ne Mail hinschicken und auf die Antwort des Mailempfängers warten.
Das eigene Postfach kann man auch selbst mit Delphimitteln abfragen und die Antwortmails / erhaltenen Fehlermeldungen auswerten.

Technisch müsste Deine Aufgabenstellung umzusetzen sein, die Frage ist halt: Wieviel Aufwand willst Du da reinstecken?

Welche "Hürden" werden Dir von den mehr oder weniger unbekannten "Partnern" entgegengestellt?

Also das beliebte Thema: Wie realisieren wir eine (mehr oder weniger) vollständige Fehler- und Ausnahmenbehandlung?

[Neutral General]

Zitat:

Zitat von MEissing's Link

Just send them an email already
No, I’m not joking. Just send your users an email.

Brauchst du die ganze Prüfung denn wirklich?
Sieht mir nach Overkill aus.

[CCRDude]

Jeder Spammer würde Jubelschreie ausstoßen, wenn sich die Existenz von Email-Postfächern so passiv testen ließe.

SMTP-Server können (konnten) das prüfen, aber ich erinnere mich grob, dass das schon vor 20 Jahren eben aus Spamvermeidungsgründen flächendeckend deaktiviert wurde.

In Sachen Datenschutz wäre die folgende heute gängige Methode wohl der Kompromiss:
Email mit Code/Link an Adresse verschicken, über den Empfang der Email vom Halter der Email-Adresse bestätigt werden muss (Link anklicken oder Code eingeben).

Bei syntaktischer Prüfung vorab bitte unbedingt in den Standard schauen, nicht einfach nur auf die üblichen verdächtigen Buchstaben prüfen... mehr als die Hälfte aller Webseite lehnen gültige Adressen z.B. mit "+" im Usernamen ab. Erlebe ich immer wieder, weil ich Googles Alias-System verwende ([e-mail] landet automatisch in Inbox [e-mail], d.h. ich kann spezifische Email-Adressen pro Dienst verwenden, ohne etwas einzurichten, und sehe sofort, wer meine Email-Adresse veruntreut hat, wenn ich mal Spam erhalte).

Schließe mich ansonsten der Overkill-Fraktion an :D

[KodeZwerg]

Zitat:

Zitat von CCRDude (Beitrag 1409067)

Jeder Spammer würde Jubelschreie ausstoßen, wenn sich die Existenz von Email-Postfächern so passiv testen ließe.

SMTP-Server können (konnten) das prüfen, aber ich erinnere mich grob, dass das schon vor 20 Jahren eben aus Spamvermeidungsgründen flächendeckend deaktiviert wurde.

In Sachen Datenschutz wäre die folgende heute gängige Methode wohl der Kompromiss:
Email mit Code/Link an Adresse verschicken, über den Empfang der Email vom Halter der Email-Adresse bestätigt werden muss (Link anklicken oder Code eingeben).

Bei syntaktischer Prüfung vorab bitte unbedingt in den Standard schauen, nicht einfach nur auf die üblichen verdächtigen Buchstaben prüfen... mehr als die Hälfte aller Webseite lehnen gültige Adressen z.B. mit "+" im Usernamen ab. Erlebe ich immer wieder, weil ich Googles Alias-System verwende ([e-mail] landet automatisch in Inbox [e-mail], d.h. ich kann spezifische Email-Adressen pro Dienst verwenden, ohne etwas einzurichten, und sehe sofort, wer meine Email-Adresse veruntreut hat, wenn ich mal Spam erhalte).

Schließe mich ansonsten der Overkill-Fraktion an :D

Ich schrieb ja das ich Neuling bin mit dem was ich vorhabe.

Delphi-Quellcode:

[A-Z0-9._%+-]+@[A-Z0-9.-]+.[A-Z]

so in etwa schaut meine Syntax-Prüfung aus um der RFC Norm zu entsprechen.
Wenn meine Theorie eh Mist ist bzw heutzutage nicht mehr brauchbar ist dann bleibt mir wohl keine andere Wahl als tatsächlich ne Mail zu versenden. (Da brauche ich keine Hilfe, da hilft mir ICS)
Dann muss ich wohl an einem Dienst arbeiten der den ganzen Tag nichts weiter macht als ein Konto abzufragen ob da was angekommen ist, automatisch was zurücksenden, User muss dann das gesendete in Dialog einfügen, fertig. Oje...... was solls, alles wird gut.

[Delphi.Narium]

Beschreib' bitte Deine Aufgabenstellung nochmal etwas genauer:

Programm hat 'nen Registriedialog.
User gibt da was ein, u. a. eine eMail-Adresse.
Du bekommst diese Infos.
Prüfen, ob es die eMail-Adresse gibt.
Wenn ja, geschieht irgendwas, wenn nein geschieht was anderes.

Eigentlich kannst Du Dir das ganze Prüfen sparen.

Ob 'ne eMail-Adresse gültig ist oder nicht erfährst Du letztlich mit (annähernder) Sicherheit nur, wenn Du 'ne Mail hinschickst und über einen darin enthaltenen Link eine Antwort bekommst.

Bekommst Du diese nicht in einer von Dir festgelegten Zeitspanne, dann verwerfe die Anfrage aus dem Registriedialog.

Das Prüfen von Fehlermeldungen im eigenen Postfach (wegen Unzustellbarkeit ...) kann die Wartezeit verkürzen, da Du dann definitiv weist, dass es "diese" eMail-Adresse nicht gibt. Du kannst Dich aber schon nicht darauf verlassen, dass Du diese Meldung bekommst.

'ne Syntaxprüfung von eMail-Adressen kann nie vollständig sein, sondern nur 'ne Näherung ergeben, die aber schlimmstenfalls auch mal 'ne gültige eMail-Adresse als falsch erkennt.

Eine Antwortmail kann man manipulieren, in dem der Absender nicht zwingend der tatsächliche Absender ist, bringt also auch keine absolute Sicherheit.

Die Antwort auf einen Link in 'ner Mail bringt Dir zumindest die Sicherheit, dass Deine Mail erfolgreich an die angegebene eMail-Adresse verschickt wurde, die Mail geöffnet wurde und der Link angeklickt wurde.

Ob sich hinter der eMail-Adresse ein Sammelpostfach befindet, das die Mails von X Fake-eMail-Adressen entgegennimmt, wirst Du nie mit letzter Sicherheit erfahren.

[KodeZwerg]

Ich glaube ich entferne einfach dieses Feature, das übersteigt meinen Horizont. Meine 5 Punkte Theorie will ich zumindest einmal umgesetzt haben um daraus zu Lernen wie die Dinge so funktionieren/funktioniert haben.
Link verschicken, User klickt Link, das bedarf doch WebServer?

Was ich vorhatte war:
Registrier-Dialog öffnet sich, Anwender gibt Daten ein, auch eine eMail Adresse, dahinter sollte ein grüner Haken bzw gelbes Fragezeichen erscheinen, mehr nicht. Ist grüner Haken da werden mehr features im Programm aktiv, ohne das ich weiß wer es benutzt, das ist mir zu diesem Zeitpunkt noch egal. Ob da nun einer "[e-mail]" eintippt oder sonst was ist mir auch egal. Ich wollte damit nicht prüfen ob Anwender derjenige ist der sagt er ist dieses oder jenes. Nur Grundsätzlich als Gimmick ein "Existiert diese eMail-Adresse oder eben nicht" um die GUI aufzuhübschen.
Später wollte ich für Support/Kauf eine sende mail funktion integrieren das man mir Bugs Wünsche Freischaltung etc schicken kann. An dieser Stelle sollte halt geprüft werden ob derjenige auch ist wer er vorgibt zu sein.

[Schokohase]

Zitat:

Zitat von KodeZwerg (Beitrag 1409082)

[...]
Ich wollte damit nicht prüfen ob Anwender derjenige ist der sagt er ist dieses oder jenes.
[...]
An dieser Stelle sollte halt geprüft werden ob derjenige auch ist wer er vorgibt zu sein.

Du solltest mit dir selbst im Reinen sein, was du nun wirklich willst, sonst klappt die Umsetzung gar nicht.

[KodeZwerg]

Beachte meine Erste Zeile, ich bin mit mir im Reinen.

Delphi-Quellcode:

Ich glaube ich entferne einfach dieses Feature, das übersteigt meinen Horizont.

Beispiel:
User tippt ein: "[e-mail]" wollte ich ursprünglich schauen, existiert "ha.se", hat "ha.se" einen SMTP usw usf. Halte die 5 Punkte rasch runterrattern lassen. Dies hat noch nichts mit einer "mach aus Demo eine Vollversion" zu tun. Das dient nur der GUI Optik.
Demo nach Vollprodukt: Das wollte ich dann im nächsten Schritt erst bewerkstelligen. Support/Kauf, wo man mich anmailen kann/muss.

[Delphi.Narium]

Ok, das ist also eine etwas andere Aufgabenstellung, als ich vermutet hatte.

Per DNS prüfen, ob es die Domaine gibt.
Abfragen, ob es einen MX-Record gibt (d. h.: Domaine hat auch 'nen Mailserver).
Per RegEx prüfen, ob die angegebene Mailadresse (weitgehend) plausibel erscheint.

Als Gimmick vollkommen ausreichend.

Für die Verarbeitung einer Antwort per Link, wird ein Webserver benötigt. Den kann man aber per Indy oder ICS ins eigene Programm einbauen.

Theoretisch:

Programm starten
eMail-Adresse eingeben lassen
Mail an diese verschicken
User öffnet in seinem Mailprogramm die Mail
Klickt auf den Link
Das Programm kann mit seinem eingebauten HTTP-Server darauf reagieren.
(Es muss halt die ganze Zeit laufen und wir gehen davon aus, dass keine Firewall oder sonstwas die Kommunikation be- bzw. verhindert.)

Die Url im Link muss dann halt ungefähr so aussehen:

Code:

http://IP-des-Rechners-auf-dem-das-Programm-läuft:Port-auf-dem-das-Programmlauscht?email=[e-mail]

also z. B.:

Code:

http://172.217.20.99:88?email=[e-mail]

Als Spielerei, um sich mit der Thematik mal auseinanderzusetzen, eine durchaus sinnvollunsinnige Aufgabe. Das dabei "abgegraste" Spektrum ist dann doch schon eher vielseitig ;-)

[KodeZwerg]

Zitat:

Zitat von Delphi.Narium (Beitrag 1409086)

Für die Verarbeitung einer Antwort per Link, wird ein Webserver benötigt. Den kann man aber per Indy oder ICS ins eigene Programm einbauen.

Das ist es!!! Mir fehlt halt die Erfahrung, von daher wusste ich nicht mal das es Möglich ist bzw habe ich so etwas erst gar nicht in Betracht gezogen. Auch Dein Quick-Check Vorschlag gefällt mir sehr gut. Genau so werde ich vorgehen, Beispiele dafür (Server) gibt es ja reichlich.

Thread mehr als Happy beendet.

Vielen Dank für all Eure Mühen mit mir!!! Ich stürze mich da jetzt mal rein, ihr rockt:thumb:

[Schokohase]

Einen HTTP-Server den die Anwendung bereitstellt ... das ist doch eher ungewöhnlich und aus mehreren Gründen nicht zu empfehlen. Aber einfach selber probieren das übt.

Eigentlich hat man einen WebService laufen, der dann von der Anwendung diese email(-Adresse) erhält. Der WebService verschickt die email mit dem Link und verarbeitet auch den Link-Aufruf vom Anwender.

Die Anwendung fragt den WebService einfach nur noch nach dem Status der Aktivierung und gut.

[Rolf Frei]

Eine 100%ige E-Mailüberprüfung kannst du nicht machen, wie dir hier ja schon mehrere geschrieben haben. Du kannst im Prinzip nur die Syntax und das Vorhandensein eines Mailsservers, der zur EMail-Domäne passt, überprüfen.

Die Syntaxprüfung kannst du mit einem RegEx machen und die Abfage, ob es einen MX-Record zu einer E-Mailadresse gibt, kannst du mit folgender Unit machen. Die Funktion RFResolveMailServer liefert dir das Gewünschte retour.

Beispiel:

Code:

s := RFResolveMailServer('8.8.8.8', 'meinefirma.de');  // Google DNS

// Wenn kein zur Domäne passender MX-Record über den Google DSN gefunden wurde, 
// durchsuchen wir nun vom Root-DNS Server aus nach unten durch die DNS-Serverlisten. 
if s = '' then  
  s := RFResolveMailServer('', 'meinefirma.de');

if (s <> '') then
  Mailserver := s
else
  Mailserver := 'E-Mail domäne ungültig';

Code:

unit RFIndyUtils;

{$IFNDEF INDY9}
  {$IF RTLVersion > 18.0}
    {$DEFINE INDY10}
  {$IFEND}
{$ENDIF}

interface

uses
  Classes, IdDNSResolver;

function RFGetMXServers(const ADNSServer: String; const ADomain: String;
  AMXServers: TStrings;  ATimeOutMS: Integer = 0): Boolean; overload;
function RFGetMXServers(ADNSResolverComp: TIdDNSResolver;
  const ADNSServer: String; const ADomain: String; AMXServers: TStrings): Boolean; overload;
{ Liefert alle zu einer Domäne passenden Mailserver (MX) als StringList retour.
    ADNSServer:  Name des zu verwendenden DNS-Servers oder leer wenn e.root-servers.net
                 verwendet werden soll.
    AResolveDomain:  Domain-Name zu dem die Mailserver (MX) retour gegeben werden soll.
    AMXServers:  Stringliste in der die Mailserver retour geliefert werden. }

function RFResolveMailServer(const ADNSServer, AResolveDomain: String;
  ATimeOutMS: Integer = 0): String;
{ Liefert die Mailserveradresse zu einer EMail zurück. Bsp: [e-mail] -> mail.domain.com
  Mögliche Rückgabewerte:
    Server gemäss DNS MX-Record oder leer wenn nichts gefunden.
  Parameter:
    ADNSServer:  Name des zu verwendenden DNS-Servers oder leer zum Start bei einem root DNS-Server (empfohlen).
    AResolveDomain:  Domain-Name zu dem der eigentliche Server-Name retour gegeben werden soll
    ATimeOutMS:  Timeout in ms, die beim Lesen gewartet werden soll bevor ein Fehler kommt.
                 Wenn <= 0 wird der Standard verwendet }


implementation

uses
  SysUtils;


function SortServers(List: TStringList; Index1, Index2: Integer): Integer;
{ RFGetMXServers StringList-Sortierungsroutine }
var
  p1, p2: Word;
begin
  p1 := Word(List.Objects[Index1]);
  p2 := Word(List.Objects[Index2]);
  if p1 < p2 then
    Result := -1
  else if p1 > p2 then
    Result := 1
  else
    Result := 0;
end;

function InternalGetMXServers(ADNSResolverComp: TIdDNSResolver; const ADNSServer: String;
  const ADomain: String; AMXServers, ASearchedNSServers: TStrings): Boolean;
var
  i : Integer;
  NSServers, MXServers: TStringList;
  ServerARecord: String;
  TmpQueryType: TQueryType;
begin
  Result := False;
  AMXServers.Clear;
  if ADNSResolverComp = nil then
    Exit;

  if ADNSServer = '' then
    ADNSResolverComp.Host := 'k.root-servers.net'
  else
    ADNSResolverComp.Host := ADNSServer;
  try
    ADNSResolverComp.Resolve(ADomain);
    if ADNSResolverComp.QueryResult.Count = 0 then
    begin
      ADNSResolverComp.Host := 'i.root-servers.net';
      ADNSResolverComp.Resolve(ADomain);
    end;
  except
    Exit;
  end;

  MXServers := nil;
  ServerARecord := '';
  for i := 0 to ADNSResolverComp.QueryResult.Count - 1 do
  begin
    if ADNSResolverComp.QueryResult[i] is TMXRecord then
    begin
      if MXServers = nil then
        MXServers := TStringList.Create;
      with TMXRecord(ADNSResolverComp.QueryResult[i]) do
        MXServers.AddObject(ExchangeServer,TObject(Integer(Preference)));
    end;
    if ADNSResolverComp.QueryResult[i] is TARecord then
      ServerARecord := TARecord(ADNSResolverComp.QueryResult[i]).Name;
  end;

  if MXServers <> nil then
  begin
    MXServers.CustomSort(SortServers);
    AMXServers.Assign(MXServers);
    FreeAndNil(MXServers);
    Result := True;
    Exit;
  end;

  NSServers := nil;
  try
    for i := 0 to ADNSResolverComp.QueryResult.Count - 1 do
    begin
      if ADNSResolverComp.QueryResult[i] is TNSRecord then
      begin
        with TNSRecord(ADNSResolverComp.QueryResult[i]) do
        begin
          if HostName <> '' then
          begin
            if NSServers = nil then
              NSServers := TStringList.Create;
            NSServers.Add(HostName);
          end;
        end;
      end;
    end;

    if NSServers <> nil then
    begin
      for i := 0 to NSServers.Count-1 do
      begin
        { Bereits durchsuchte Subdomains sollen nicht mehr durchsucht werden }
        if ASearchedNSServers.IndexOf(NSServers[i]) = -1 then
        begin
          Result := InternalGetMXServers(ADNSResolverComp, NSServers[i], ADomain,
            AMXServers, ASearchedNSServers);
          if Result then
            Exit;
          ASearchedNSServers.Add(NSServers[i]);
        end;
      end;
    end
    else if ServerARecord <> '' then
    begin
      { Top Level no MX found, so we report the A record }
{$IFDEF INDY10}
      TmpQueryType := ADNSResolverComp.QueryType;
      ADNSResolverComp.QueryType := [qtA];
{$ELSE}
      TmpQueryType := ADNSResolverComp.QueryRecords;
      ADNSResolverComp.QueryRecords := [qtA];
{$ENDIF}
      try
        ADNSResolverComp.Resolve(ADomain);
        if ADNSResolverComp.QueryResult.Count <> 0 then
        begin
          AMXServers.Add(ADomain);
          Result := True;
        end;
      finally
{$IFDEF INDY10}
        ADNSResolverComp.QueryType := TmpQueryType;
{$ELSE}
        ADNSResolverComp.QueryRecords := TmpQueryType;
{$ENDIF}
      end;
    end;
  finally
    if NSServers <> nil then
      NSServers.Free;
  end;
end;

function RFGetMXServers(ADNSResolverComp: TIdDNSResolver; const ADNSServer: String;
  const ADomain: String; AMXServers: TStrings): Boolean; overload;
var
  SearchedNSServers: TStringList;
begin
  SearchedNSServers := TStringList.Create;
  try
    Result := InternalGetMXServers(ADNSResolverComp, ADNSServer, ADomain,
      AMXServers, SearchedNSServers);
  finally
    SearchedNSServers.Free;
  end;
end;


function RFGetMXServers(const ADNSServer: String; const ADomain: String;
  AMXServers: TStrings; ATimeOutMS: Integer = 0): Boolean;
var
  DNSResolver: TIdDNSResolver;
begin
  DNSResolver := TIdDNSResolver.Create(nil);
  try
{$IFDEF INDY10}
    if ATimeOutMS <> 0 then
      DNSResolver.WaitingTime := ATimeOutMS
    else
      DNSResolver.WaitingTime := 3000;
    DNSResolver.QueryType := [qtMX];
{$ELSE}
    if ATimeOutMS <> 0 then
      DNSResolver.ReceiveTimeout := ATimeOutMS
    else
      DNSResolver.ReceiveTimeout := 3000;
    DNSResolver.QueryRecords := [qtMX];
{$ENDIF}

    Result := RFGetMXServers(DNSResolver, ADNSServer, ADomain, AMXServers);
  finally
    DNSResolver.Free;
  end;
end;

function RFResolveMailServer(const ADNSServer, AResolveDomain: String;
  ATimeOutMS: Integer = 0): String;
var
  MXServers: TStringList;
begin
  Result := '';
  MXServers := TStringList.Create;
  try
    if RFGetMXServers(ADNSServer, AResolveDomain, MXServers, ATimeOutMS) then
      Result := Trim(MXServers[0]);
  finally
    MXServers.Free;
  end;
end;


end.

[KodeZwerg]

@Schokohase:
Für Leute die keinen Eigenen Web-Server betreiben finde ich diese Idee total klasse von Delphi.Narium.
Ich muss halt Proxy/Firewall features mit reinbringen damit es überall laufen sollte, da lese ich mich gerade rein.

Zu Übungszwecke für mich als Neuling, finde ich es ein tolles Nebenprojekt um Erfahrung sammeln zu können.

Ob und in wie fern ich meine daraus gewonnenen Skills dann im Produkt umsetze weiß ich gerade selbst noch nicht.
Grundsätzlich hat bereits Delphi.Nariums Post meinen Horizont erweitert. Damit werde ich eine Weile beschäftigt sein.

*da war was rotes mit ellenlangen Text, ich hab auf Antworten geklickt.


@Rolf Frei: Vielen Dank für diesen umfangreichen und vor allem kommentierten Source, das ist echt voll nett von Dir!

[Schokohase]

Du solltest dabei bedenken:

Wenn du von irgendeinem Rechner eine email direkt an den Mailserver des Empfänger verschickst, dann wird diese Mail mit sehr hoher Wahrscheinlichkeit als SPAM betrachtet (denn so machen das die SPAM-Schleudern auch)

Wenn du die Mails über deinen Mail-Provider versendest (um dieser SPAM Falle zu entgehen), dann müssen der Anwendung die Zugangsdaten bekannt sein (was blöd ist, denn dann hat der Anwender diese Zugangsdaten auch und kann sich diese mit mehr oder weniger Aufwand beschaffen)

Keinen WebServer zu haben ist nur faule Ausrede, denn es gibt auch kostenlose Angebote die dafür taugen.

[KodeZwerg]

Zitat:

Zitat von Schokohase (Beitrag 1409105)

Wenn du von irgendeinem Rechner eine email direkt an den Mailserver des Empfänger verschickst, dann wird diese Mail mit sehr hoher Wahrscheinlichkeit als SPAM betrachtet (denn so machen das die SPAM-Schleudern auch)

Zur Kenntnis genommen, sind halt alle Komponenten die eMail direkt versenden untauglich, okay, dann lasse ich von meiner App den vorhandenen eMail Client starten oder den User entscheiden, das sollte diesen Punkt aushebeln.

Zitat:

Zitat von Schokohase (Beitrag 1409105)

Keinen WebServer zu haben ist nur faule Ausrede, denn es gibt auch kostenlose Angebote die dafür taugen.

Falls ich es noch nicht erwähnt habe, ich bin Neuling im Umgang mit Delphi und Online Aktivitäten.
Ich habe mir mal einen RSS Reader für die DP gebastelt und herausgefunden wie ich Html Quelltext bekomme, das wars auch schon.

Ich bin im Urlaub und wollte eigentlich nur einen Registrierungs-Dialog auf Vordermann bringen, nicht lernen wie ich einen WebServer betreibe/installiere/bekomme/etc pp.

[himitsu]

Zitat:

Zitat von KodeZwerg (Beitrag 1409070)

Delphi-Quellcode:

[A-Z0-9._%+-]+@[A-Z0-9.-]+.[A-Z]

so in etwa schaut meine Syntax-Prüfung aus um der RFC Norm zu entsprechen.

Und was ist mit meiner Umlautdomain?

http://emailregex.com/ und das ist noch eine "kurze" Version :stupid:

Zitat:

Wenn du von irgendeinem Rechner eine email direkt an den Mailserver des Empfänger verschickst, dann wird diese Mail mit sehr hoher Wahrscheinlichkeit als SPAM betrachtet (denn so machen das die SPAM-Schleudern auch)

und wenn du zu viele "Test"-Mails mit dem selben Inhalt abschickst, dann kann es auch passieren, dass du auf Spamlisten landest.

Außerdem geben nicht alle Mailserver bei falschen/ungültigen Empfängern auch eine "Negativ"-Meldung raus.
IMHO Web.de, GMX und Co. machen das nicht, damit niemand "gültige" Adressen suchen kann, um sie anschließend Resourcensparender zuspamen zu können, indem er z.B. einfach so blind irgendwas (Brutefoce/Wörterbuchatacke/...) hinschickt.
Eine Mail an eine ungültige Adresse landet da einfach im Nirvana.
Mein eigener Webserver hat ein CatchAll-Postfach drauf, in dem alles landet, was keiner gültigen existierenden Adresse angehört und ich schaue da fast niemals rein ... es kann somit niemand durch Testen rausbekommen, welches die echten Postfächer sind.

Genauso ist es eine sicherere Idee, wenn Loginversuche nicht sagen "Name ist falsch", sondern immer "Passwort stimmt nicht", denn so kann nicht nach gültigen Loginnamen gesucht werden, woraufhin "nur" noch das Passwort zu finden wäre. (Webseite, Server, alles...)

[Schokohase]

Zitat:

Zitat von KodeZwerg (Beitrag 1409112)

okay, dann lasse ich von meiner App den vorhandenen eMail Client starten oder den User entscheiden, das sollte diesen Punkt aushebeln.

Womit du das ganze Verfahren ad absurdum führst (oder auch aushebelst).

Der Benutzer sieht also in seinem Mail-Client die Mail um diese an die email-Adresse zu verschicken, natürlich inkl. dem Link zu dem Webserver womit ja überprüft werden soll, ob diese email-Adresse existiert.

Anstatt die mail zu versenden kann den Anwender aber doch auch direkt den Link anklicken und wird registriert.

[KodeZwerg]

Ja das ist mir im Nachhinein auch aufgefallen. Habs total primitiv mit nem "MAILTO:" Kommando probiert.
Ich bastel mal an HTTP-Server Experiment weiter um zu schauen wie was womit reagiert und wo dort dann böse Lücken sich auf tun. Von echten WebServer/Mail-Versand habe ich null Ahnung, Versuch macht klug. Umlaute in Domänen kenne ich ebenso wenig.
Zuviele Mail Problem habe auch zur Kenntnis genommen, da behelfe ich mir mit einem Timer, eingestellt auf 300000 MSek Pause.

Ich werde mich auf jeden fall noch weiter mit dem Thema beschäftigen und reinlesen. Mal sehen was am Ende dabei rauskommt, es eilt ja nicht. Aber das direkte Mail Versenden Komponenten alle Schrott sind, au backe.

Wenn mein selbst-experiment mit App-Server fertig ist fange ich an mich dem Mail-Thema intensiver zu widmen und Schritt für Schritt zu nähern. Danach widme ich mich echten WebServern, wie die so funktionieren, was ich dabei zu beachten habe etc..

Wenn dies alles getan ist sollte ich zumindest über ein paar Grundkenntnisse verfügen die ich dann hoffentlich erfolgreich in etwas umsetzen kann.

[Schokohase]

Zitat:

Zitat von KodeZwerg (Beitrag 1409122)

Aber das direkte Mail Versenden Komponenten alle Schrott sind, au backe.

Wieso sind die Schrott?

Unwissenheit ist per se nicht schlimm, dagegen kann man etwas tun. Aber aus Unwissenheit heraus die Arbeit von anderen schlecht reden lässt mich an der Qualität deiner Kinderstube zweiflen.

[himitsu]

Zitat:

Zitat von KodeZwerg (Beitrag 1409122)

Umlaute in Domänen kenne ich ebenso wenig.

www.frauengeflüster.de also ärger@frauengeflüster.de
oder www.müllermilch.de

[Delphi.Narium]

Um in dieses umfangreiche "Gewusel" mal ein bisserl 'ne Linie zu bekommen, wäre mein Vorgehen:

• Eingabe von eMail-Adressen ermöglichen
• eMail-Adressen auf syntaktische Richtigkeit prüfen (Annäherung reicht, Vollständigkeit kaum möglich)
• DNS-Abfrage bezüglich der Domaine aus der eMail-Adresse
• Prüfen, ob diese Domaine über einen Mailserver verfügt
• über einen eigenen Mail-Account 'ne Mail dorthin schicken
• des gleichen per Programm (unter Nutzung des Accounts aus dem vorherigen Schritt) eine Mail verschicken
• beim Empfänger-Account nachschauen, ob die Mail ankommt
• diese Prüfung im eigenen Programm nachvollziehen (gezielte Postfachabfrage)
• den Inhalt der Mail im Programm auf Vollständigkeit ... auswerten
• einen (kleinen) Webserver bauen, der als normales Programm läuft und auf den verschickten Link reagiert
• wenn er reagiert den Link auswerten und daraus resultierende Funktionen implementieren

(Was vergessen? Macht nix, dann wird die Liste eben an der passenden Stelle erweitert ;-))

Zum Probieren kann das ruhig alles in einer Exe sein, wenn man es vernünftig in Klassen kapselt, kann man diese dann später ins "Kundenprogramm", 'nen WebService, 'nen eigenen Mailserver ... "verteilen".
Es geht halt darum zu verstehen wie es geht und nicht darum eine sofort sinnvolle Applikation zu erstellen.

Alle mir bekannten Komponenten dafür arbeiten "spezifikationskonform", aber die Nutzung ist nicht zwingend trivial und da kann dann schonmal der Eindruck entstehen, das sei alles Schrott, bis dann irgendwann der Aha-Effekt aufkommt: "Ach sooooo geeeeht das, ist ja gaaanz einfach, warum sagt mir das denn niemand." Halt normales Programmiererleben ;-)

[KodeZwerg]

Zitat:

Zitat von Schokohase (Beitrag 1409126)

Aber aus Unwissenheit heraus die Arbeit von anderen schlecht reden lässt mich an der Qualität deiner Kinderstube zweiflen.

Wen habe ich schlecht geredet? Ich wusste nicht das hier eine Analyse über meine Herkunft stattfindet, also steige mal bitte vom Ross, solche Sticheleien kann man sich schenken.

Zitat:

Zitat von Schokohase (Beitrag 1409126)

Wieso sind die Schrott?

Wegen:

Zitat:

Zitat von Schokohase (Beitrag 1409105)

Wenn du von irgendeinem Rechner eine email direkt an den Mailserver des Empfänger verschickst, dann wird diese Mail mit sehr hoher Wahrscheinlichkeit als SPAM betrachtet (denn so machen das die SPAM-Schleudern auch)

Entweder versteh ich nicht was Du da von Dir gibst oder ich versteh es momentan noch falsch. Was ich stark vermute.
Was nützt mir eine tolle Komponente zum Mail Versand wenn es eh nicht ankommt, man kann es 100pro auch besser ausdrücken aber unterm Strich kommt raus das ich es nicht verwenden kann da es keinen Sinn erfüllt. Wie ne Postkarte ohne Marken.
Aber ich Lerne ja noch und vielleicht klärt sich das Missverständnis dabei auf.

Zitat:

Zitat von himitsu (Beitrag 1409129)

www.müllermilch.de

Ahhh, habs Verstanden. Danke dafür.

Zitat:

Zitat von Delphi.Narium (Beitrag 1409131)

Alle mir bekannten Komponenten dafür arbeiten "spezifikationskonform", aber die Nutzung ist nicht zwingend trivial und da kann dann schonmal der Eindruck entstehen, das sei alles Schrott, bis dann irgendwann der Aha-Effekt aufkommt: "Ach sooooo geeeeht das, ist ja gaaanz einfach, warum sagt mir das denn niemand." Halt normales Programmiererleben ;-)

Ich arbeite daran, aber erstmal mit eigenen Server rumspielen und schauen was es da so alles zu Entdecken gibt, macht mir Spaß diese neue Funktionalität.
Und ja, momentan ist alles in einer .exe zum rumprobieren enthalten, StepByStep gehts voran.

[Delphi.Narium]

Stell' Dir 'ne EMail wie 'nen normalen Brief vor:

Wenn Du wissen willst, ob der angekommen ist, muss Du den Empfänger fragen.

Bei 'nem Brief kannst Du die Post bitten, Dir die Empfangsbestätigung zu schicken, kostet aber extra, da hast Du quasi 'nen Boten, der Dir das Nachfragen abnimmt, weil er bei der erfolgreichen Zustellung dabei war und Dich darüber informiert.

Im Mailverkehr hast Du sowas schlicht und einfach nicht.

Die Mail ist raus und damit für Dich nicht mehr kontrollierbar.

Es kann sein, dass es Mailserver gibt, die so nett sind, Dich über eine Unzustellbarkeit zu informieren. Darauf verlassen, dass alle das tun? Vergiss es.

Lesebestätigung vom Empfänger anfordern?

Manche schicken diese automatisch, auch wenn sie nicht gelesen haben, manche, wenn sie gelesen haben, manche ignorieren sie.

Also auch kein Verlass.

Das ist kein Problem irgendwelcher Komponenten. Alle Mailclients und Mailserver haben das Problem.

Bei 'ner mit Outlook (oder beliebigem anderen Client) verschickten Mail erfährst Du auch nicht zwingend, ob sie angekommen ist oder unzustellbar war. Es kann sein, dass Du es erfährst, aber drauf verlassen kannst Du Dich nicht.

[Schokohase]

Wenn du sagst, dass die Komponenten Schrott sind, dann ist das für mich keine Lobhudelei.

Allerdings sind die kein Schrott, sondern machen das, was sie machen sollen.

Du hast die Wahl ob du die Mail über deinen SMTP Server verschickst oder direkt an den SMTP Server des Empfängers. Technisch gesehen ist das gleich, allerdings wird dieses direkte Abliefern von den meisten Mail-Servern direkt als SPAM behandelt.

Es ist also dein Verhalten/deine Art der Verwendung der Komponente, die diesen - wie du es bezeichnest - „Schrott“ produziert. Die Komponente kann da nichts zu.

[Redeemer]

Zitat:

Zitat von KodeZwerg (Beitrag 1409042)

Später würde ich gerne meine App erweitern mit der Möglichkeit ein eMail Formular an mich selbst zu versenden.

Nach der Antwort von MEißing hat sich der gesamte Thread eigentlich erledigt, aber hier wird jetzt ein Fass aufgemacht wegen eines Programms mit wie vielen (bzw. wenigen) angestrebten Nutzern? Das ist schon ein wenig mit Kanonen auf Spatzen zu schießen.
Ich lass Nutzer mit 'ne richtige E-Mail schicken und beantworte jede Mail von meinen etwa 100.000 Nutzern persönlich. Gut, da kommt vielleicht alle paar Tage mal eine. Gute Software – und in die wäre die Zeit besser investiert – braucht wenig Support.

[KodeZwerg]

@Delphi.Narium: Danke, so ein bisschen wusste ich ja schon, nun noch mehr :thumb:

Zitat:

Zitat von Schokohase (Beitrag 1409142)

Du hast die Wahl ob du die Mail über deinen SMTP Server verschickst oder direkt an den SMTP Server des Empfängers. Technisch gesehen ist das gleich, allerdings wird dieses direkte Abliefern von den meisten Mail-Servern direkt als SPAM behandelt.

Ha! Sag ich ja, hab die Aussage falsch aufgefasst und ersetze "die sind Schrott" mit "mein Verständnis bis zu dem Zeitpunkt war Schrott" wenn ich darf.

@Redeemer: Für nen Neuling wie mich ist es eben nicht gleich mit einer "Check ob Syntax stimmt" erledigt.
Für Dich als alten Hasen ist das alles wie Wasser trinken, da reicht ein Stichwort und Du weißt sofort Bescheid.
Da es sich immer noch um einen Registrier-Dialog handelt und nicht um eine Applikation an sich, verstehe ich die Aussage nicht.
Dieser Dialog soll dann nach und nach in mehr und mehr Anwendungen von mir eingesetzt werden bzw alte Mechanismen mit neueren Ersetzen. Ob es 1 Nutzer ist oder 100000 sollte meines Erachtens gleich sein solange das Grundgerüst funktioniert.




Dank des heutigen plauschs habe ich viel Lernen können, nicht nur die eine Sache aus Post #1 sondern auch Meinungen die davon abweichen mir anhören können mit Vor- und Nachteilen und das mein Vorhaben wie ich es mir Vorgestellt hatte nicht Möglich ist. Das .exe Server Experiment hält mich immer noch Gefangen, danach kümmer ich mich um Mail.

[Delphi.Narium]

@Redeemer

Prinzipiell hast Du ja recht, ein Programm, dass alles hier erwähnte "abfackelt" ist eigentlich unsinnig.

Aber es geht ja "nur" darum, von all den Themen erstmal den Ansatz einer Ahnung zu bekommen, um dann damit sinnvolles realisieren zu können oder zu erkennen, dass das eine oder andere Gedachte im realen Leben nicht sinnvoll einzusetzen ist oder man auch einfach nur (unter Ermangelung der notwendigen Kenntnis) etwas meint "mal eben" umsetzen zu können, was aber letztlich (egal mit welchem Aufwand) nicht umsetzbar ist. Z. B.: Die sichere und absolut fehlerfrei Verifizierung von Mail-Adressen.

'nen Webserver als Exe mit GUI hab' ich mir vor Jahren gebaut. Der funktioniert immernoch, genauso sicher wie ein WebService. Die Konfiguration über die GUI ist aber halt so schön einfach und sofort wirksam. Erweitert wird er mit ISAPI-Dlls, CGI-Programmen ...

Mein kontextsensitive Hilfe in diversen Programm nutzt auch 'nen im Programm enthaltenen Webserver, das merkt keiner und die Hilfe besteht aus HTML-Dateien. (Aussehen entspricht (fast) dem der CHM-Hilfen.) Das liegt alles in 'nem ZIP mit 'nem ähnlichen Aufbau wie EPub-Dateien. Das geht wunderbar, auch wenn diese Lösung vielleicht doch eher etwas "ungewöhnlich", da weitgehend unüblich, ist. Aber seit dem muss ich meine Software nicht mehr an die jeweils aktuelle Hilfeversion von Windows anpassen. (Und sie könnte ggfls. ohne Änderung auch auf anderen Plattformen funktionieren.)

Innovationen entstehen nunmal dadurch, dass man vom Gewohnten abweicht und mal ein Problem um 'ne Ecke löst, von der vorher niemand wusste, dass sie da ist ;-)

Und Lernen unter Zuhilfenahme von unsinnigen Aufgaben macht durchaus Spaß. Es fördert die Kreativität und das Denken um (für Logik eigentlich ungeeignete) Ecken.

[Rollo62]

TLDR;

Bin nicht sicher ob hier schon das Standartverfahren angesprochen wurde.

• Erzeue einen Token
• Lege einen Link mi dem Token auf deinem Webserver an
• Schicke Email mit Bestätigungslink zum Nutzer
• Wenn der den unique Link klickt ist deine Email bestätigt

Rollo

[KodeZwerg]

So in etwa gehe ich auch vor. Im Detail halt für mich passend abgeändert aber Sinngemäß kommt das selbe hinten raus.
Hab das ganze hinter einem Schild-Symbol (Admin-Mode) verfrachtet weil der Prozess dann kurzzeitig zu einem WebServer wird, alles nur mit Zustimmung des Users.