Ja. Das Mail ist „kaputt“. bearbeitet von Raketenwilli 08.02.2023 22:37 Oh. Mein. Gott. Ich hab das lange nicht mehr so gemacht... (seit ich den PHP-Mailer kenne und deshalb das Schreiben einer eigenen Libary abgebrochen habe) > ~~~ > `Return-Path: <bstastatur@gmail.com> > Received: from PCMartin (p578a9728.dip0.t-ipconnect.de. [87.138.151.40]) > by smtp.gmail.com with ESMTPSA id d3-20020a056000114300b002c3f9404c45sm2346701wrx.7.2023.02.08.04.22.18 > for <bstastatur@gmail.com> > (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); > Wed, 08 Feb 2023 04:22:19 -0800 (PST) > From: <bstastatur@gmail.com> > To: <bstastatur@gmail.com> > Subject: Testmail > Date: Wed, 8 Feb 2023 13:16:15 +0100 > Message-ID: <047701d93bb7$24e4d210$6eae7630$@gmail.com> > MIME-Version: 1.0 > Content-Type: multipart/mixed; > boundary="----=_NextPart_000_0478_01D93BBF.86B37340" > # Geraffel > ~~~ Ja. Es hilft tatsächlich - weil ich nun sehe, was fehlt. Nämlich genau das, was ich oben aufgeführt habe. Generell ist das erzeugte Mail also „kaputt“. Du musst in der Dok zu Deiner Outlook-DLL suchen, wie man - den oder die Empfänger (auch CC, BCC) - den Absender, den oder die Empfänger der Antwort - das Subjekt - die Ankündigung des Multipart-Teils - die Ankündigung des Mixed-Teils - den Text-Teil - den HTML-Teil (wegen dieser Teile heisst es ja "multipart/mixed") - die Ankündigung der übrigen Anhänge - die übrigen Anhänge selbst beifügt. Bei einem Content-Type: `multipart/mixed;` schließt sich als nächstes ein Plain-Text-Teil an (mit entsprechendem Header). **Wenn man ein KORREKTES Mail mit Text, HTML und Anhängen „von Hand“ machen will..., dann sieht das im Kern so aus:** ~~~ Content-Type: multipart/mixed; boundary="Boundary_AAAAA" -- Boundary_AAAAA" Content-Type: multipart/alternative; boundary="Boundary_BBBBB" --Boundary_BBBBB Content-Type: text/plain;charset=UTF-8 Content-Transfer-Encoding: quoted-printable Hier die Nachricht im Text-Format für Mailempfänger, welche kein HTML empfangen oder darstellen können oder das bewusst nicht wollen... --Boundary_BBBBB Content-Type: text/html;charset=UTF-8 Content-Transfer-Encoding: quoted-printable <!doctype html> <html dir="ltr" lang="de"> <h1>Hier die Nachricht im HTML-Format.</h1> <p>Denke aber an das quoted-printable </html> --Boundary_BBBBB-- --Boundary_AAAAA Content-Type: application/octet-stream; name=Datei-1.pdf Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename=Datei-1.pdf JVBERi0xLjMNCiXi48/TDQo2IDAgb2JqDQo8PA0KL1R5cGUgL1BhZ2UNCi9QYXJlbnQgMiAwIFIN YWI+XQ0KPj4NCnN0YXJ0eHJlZg0KMjU2NDE5DQolJUVPRg== --Boundary_AAAAA Content-Type: application/octet-stream; name=Datei-2.pdf Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename=Datei-2.pdf JVBERi0xLjMNCiXi48/TDQo2IDAgb2JqDQo8PA0KL1R5cGUgL1BhZ2UNCi9QYXJlbnQgMiAwIFIN YWI+XQ0KPj4NCnN0YXJ0eHJlZg0KMjU2NDE5DQolJUVPRg== --Boundary_AAAAA-- ~~~ Hinweis: Ich habe oben natürlich weder das HTML noch den Text gequotet. Du musst das aber tun- übrigens auch Subjekt und ggf. Namen bei den Adressen (from, to. replto, cc, bcc) * **Beachte** die "-"-Symbole **vor** und **nach** den Boundary. * **Beachte** deren Verschachtelung * **Beachte**, dass der Boundary **strikt unique** sein muss. Üblich ist ein Konstrukt aus Zeit (Mikrosekunden) und großer Zufallszahl. Sonst bekommt der Empfänger, besonders wenn sein Programm alle Mails in einer Datei speichert, recht herzliche Probleme! Im Prinzip hat das Mail, welches Du senden willst, folgenden Aufbau (ich lehne mich mal an Javascript bzw. PHP an um die Verschachtelung zu zeigen. ~~~ Mail { Mailheader { .... } Multipart Mixed { Multipart Alternative { Text-Part { header { } Nutzlast { } } HTML-Part { header { } Nutzlast { } } } } Anhang 1 { header { } Nutzlast { } } ... Anhang N { header { } Nutzlast { } } } ~~~ * Jede Ebene (Einzugstiefe) braucht hierbei einen eigenen Boudary! * Außerdem kannst Du, weil in Mails nur ASCII erlaubt ist, auch das HTML mit base64 kodieren, musst das dann aber angeben. * Und noch etwas: in Mails dürfen Zeilen keine 1000 Zeichen lang sein. Üblich ist es, diese nach 77 Zeichen umzubrechen. Das betrifft insbesondere die bas64-kodierten Teile, die müssen nach der Kodierung noch umgebrochen werden, beim Dekodieren muss das empfangende Programm dann nichts machen, weil alle (mir bekannten) Base64-Dekodierer Zeilenumbrüche im Input ignorieren, weil die ja kodiert sind. * Und vermeide, wenn Du quoted-printable verwendest, in der Nutzlast Zeilen, die nur aus einem Punkt bestehen. Das signalisiert das Ende des Mails... **Literatur:** <https://www.rfc-editor.org/rfc/rfc5322> (Als Beginn)
Ja. Das Mail ist „kaputt“. bearbeitet von Raketenwilli 08.02.2023 23:05 > ~~~ > `Return-Path: <bstastatur@gmail.com> > Received: from PCMartin (p578a9728.dip0.t-ipconnect.de. [87.138.151.40]) > by smtp.gmail.com with ESMTPSA id d3-20020a056000114300b002c3f9404c45sm2346701wrx.7.2023.02.08.04.22.18 > for <bstastatur@gmail.com> > (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); > Wed, 08 Feb 2023 04:22:19 -0800 (PST) > From: <bstastatur@gmail.com> > To: <bstastatur@gmail.com> > Subject: Testmail > Date: Wed, 8 Feb 2023 13:16:15 +0100 > Message-ID: <047701d93bb7$24e4d210$6eae7630$@gmail.com> > MIME-Version: 1.0 > Content-Type: multipart/mixed; > boundary="----=_NextPart_000_0478_01D93BBF.86B37340" > # Geraffel > ~~~ Ja. Es hilft tatsächlich - weil ich nun sehe, was fehlt. Nämlich genau das, was ich oben aufgeführt habe. Generell ist das erzeugte Mail also „kaputt“. Du musst in der Dok zu Deiner Outlook-DLL suchen, wie man - den oder die Empfänger (auch CC, BCC) - den Absender, den oder die Empfänger der Antwort - das Subjekt - die Ankündigung des Multipart-Teils - die Ankündigung des Mixed-Teils - den Text-Teil - den HTML-Teil (wegen dieser Teile heisst es ja "multipart/mixed") - die Ankündigung der übrigen Anhänge - die übrigen Anhänge selbst beifügt. Bei einem Content-Type: `multipart/mixed;` schließt sich als nächstes ein Plain-Text-Teil an (mit entsprechendem Header). **Wenn man ein KORREKTES Mail mit Text, HTML und Anhängen „von Hand“ machen will..., dann sieht das im Kern so aus:** ~~~ Content-Type: multipart/mixed; boundary="Boundary_AAAAA" -- Boundary_AAAAA" Content-Type: multipart/alternative; boundary="Boundary_BBBBB" --Boundary_BBBBB Content-Type: text/plain;charset=UTF-8 Content-Transfer-Encoding: quoted-printable Hier die Nachricht im Text-Format für Mailempfänger, welche kein HTML empfangen oder darstellen können oder das bewusst nicht wollen... --Boundary_BBBBB Content-Type: text/html;charset=UTF-8 Content-Transfer-Encoding: quoted-printable <!doctype html> <html dir="ltr" lang="de"> <h1>Hier die Nachricht im HTML-Format.</h1> <p>Denke aber an das quoted-printable </html> --Boundary_BBBBB-- --Boundary_AAAAA Content-Type: application/octet-stream; name=Datei-1.pdf Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename=Datei-1.pdf JVBERi0xLjMNCiXi48/TDQo2IDAgb2JqDQo8PA0KL1R5cGUgL1BhZ2UNCi9QYXJlbnQgMiAwIFIN YWI+XQ0KPj4NCnN0YXJ0eHJlZg0KMjU2NDE5DQolJUVPRg== --Boundary_AAAAA Content-Type: application/octet-stream; name=Datei-2.pdf Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename=Datei-2.pdf JVBERi0xLjMNCiXi48/TDQo2IDAgb2JqDQo8PA0KL1R5cGUgL1BhZ2UNCi9QYXJlbnQgMiAwIFIN YWI+XQ0KPj4NCnN0YXJ0eHJlZg0KMjU2NDE5DQolJUVPRg== --Boundary_AAAAA-- ~~~ Hinweis: Ich habe oben natürlich weder das HTML noch den Text gequotet. Du musst das aber tun- übrigens auch Subjekt und ggf. Namen bei den Adressen (from, to. replto, cc, bcc) * **Beachte** die "-"-Symbole **vor** und **nach** den Boundary. * **Beachte** deren Verschachtelung * **Beachte**, dass der Boundary **strikt unique** sein muss. Üblich ist ein Konstrukt aus Zeit (Mikrosekunden) und großer Zufallszahl. Sonst bekommt der Empfänger, besonders wenn sein Programm alle Mails in einer Datei speichert, recht herzliche Probleme! Im Prinzip hat das Mail, welches Du senden willst, folgenden Aufbau (ich lehne mich mal an Javascript bzw. PHP an um die Verschachtelung zu zeigen. ~~~ Mail { Mailheader { .... } Multipart Mixed { Multipart Alternative { Text-Part { header { } Nutzlast { } } HTML-Part { header { } Nutzlast { } } } } Anhang 1 { header { } Nutzlast { } } ... Anhang N { header { } Nutzlast { } } } ~~~ * Jede Ebene (Einzugstiefe) braucht hierbei einen eigenen Boudary! * Außerdem kannst Du, weil in Mails nur ASCII erlaubt ist, auch das HTML mit base64 kodieren, musst das dann aber angeben. * Und noch etwas: in Mails dürfen Zeilen keine 1000 Zeichen lang sein. Üblich ist es, diese nach 77 Zeichen umzubrechen. Das betrifft insbesondere die bas64-kodierten Teile, die müssen nach der Kodierung noch umgebrochen werden, beim Dekodieren muss das empfangende Programm dann nichts machen, weil alle (mir bekannten) Base64-Dekodierer Zeilenumbrüche im Input ignorieren, weil die ja kodiert sind. * Und vermeide, wenn Du quoted-printable verwendest, in der Nutzlast Zeilen, die nur aus einem Punkt bestehen. Das signalisiert das Ende des Mails... **Literatur:** <https://www.rfc-editor.org/rfc/rfc5322> (Als Beginn)
Ja. Das Mail ist „kaputt“. bearbeitet von Raketenwilli 08.02.2023 23:01 > ~~~ > `Return-Path: <bstastatur@gmail.com> > Received: from PCMartin (p578a9728.dip0.t-ipconnect.de. [87.138.151.40]) > by smtp.gmail.com with ESMTPSA id d3-20020a056000114300b002c3f9404c45sm2346701wrx.7.2023.02.08.04.22.18 > for <bstastatur@gmail.com> > (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); > Wed, 08 Feb 2023 04:22:19 -0800 (PST) > From: <bstastatur@gmail.com> > To: <bstastatur@gmail.com> > Subject: Testmail > Date: Wed, 8 Feb 2023 13:16:15 +0100 > Message-ID: <047701d93bb7$24e4d210$6eae7630$@gmail.com> > MIME-Version: 1.0 > Content-Type: multipart/mixed; > boundary="----=_NextPart_000_0478_01D93BBF.86B37340" > # Geraffel > ~~~ Ja. Es hilft tatsächlich - weil ich nun sehe, was fehlt. Nämlich genau das, was ich oben aufgeführt habe. Generell ist das erzeugte Mail also „kaputt“. Du musst in der Dok zu Deiner Outlook-DLL suchen, wie man - den oder die Empfänger (auch CC, BCC) - den Absender, den oder die Empfänger der Antwort - das Subjekt - die Ankündigung des Multipart-Teils - die Ankündigung des Mixed-Teils - den Text-Teil - den HTML-Teil (wegen dieser Teile heisst es ja "multipart/mixed") - die Ankündigung der übrigen Anhänge - die übrigen Anhänge selbst beifügt. Bei einem Content-Type: `multipart/mixed;` schließt sich als nächstes ein Plain-Text-Teil an (mit entsprechendem Header). **Wenn man ein KORREKTES Mail mit Text, HTML und Anhängen „von Hand“ machen will..., dann sieht das im Kern so aus:** ~~~ Content-Type: multipart/mixed; boundary="Boundary_AAAAA" -- Boundary_AAAAA" Content-Type: multipart/alternative; boundary="Boundary_BBBBB" --Boundary_BBBBB Content-Type: text/plain;charset=UTF-8 Content-Transfer-Encoding: quoted-printable Hier die Nachricht im Text-Format für Mailempfänger, welche kein HTML empfangen oder darstellen können oder das bewusst nicht wollen... --Boundary_BBBBB Content-Type: text/html;charset=UTF-8 Content-Transfer-Encoding: quoted-printable <!doctype html> <html dir="ltr" lang="de"> <h1>Hier die Nachricht im HTML-Format.</h1> <p>Denke aber an das quoted-printable </html> --Boundary_BBBBB-- --Boundary_AAAAA Content-Type: application/octet-stream; name=Datei-1.pdf Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename=Datei-1.pdf JVBERi0xLjMNCiXi48/TDQo2IDAgb2JqDQo8PA0KL1R5cGUgL1BhZ2UNCi9QYXJlbnQgMiAwIFIN YWI+XQ0KPj4NCnN0YXJ0eHJlZg0KMjU2NDE5DQolJUVPRg== --Boundary_AAAAA Content-Type: application/octet-stream; name=Datei-2.pdf Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename=Datei-2.pdf JVBERi0xLjMNCiXi48/TDQo2IDAgb2JqDQo8PA0KL1R5cGUgL1BhZ2UNCi9QYXJlbnQgMiAwIFIN YWI+XQ0KPj4NCnN0YXJ0eHJlZg0KMjU2NDE5DQolJUVPRg== --Boundary_AAAAA-- ~~~ Hinweis: Ich habe oben natürlich weder das HTML noch den Text gequotet. Du musst das aber tun- übrigens auch Subjekt und ggf. Namen bei den Adressen (from, to. replto, cc, bcc) * Beachte die "-"-Symbole **vor** und **nach** den Boundary. * Beachte deren Verschachtelung + Beachte, dass der Boundary **strikt unique** sein muss. Üblich ist ein Konstrukt aus Zeit (Mikrosekunden) und großer Zufallszahl. Sonst bekommt der Empfänger, besonders wenn sein Programm alle Mails in einer Datei speichert, rechtherzliche Probleme Im Prinzip hat das Mail, welches Du senden willst, folgenden Aufbau (ich lehne mich mal an Javascript bzw. PHP an um die Verschachtelung zu zeigen. ~~~ Mail { Mailheader { .... } Multipart Mixed { Multipart Alternative { Text-Part { header { } Nutzlast { } } HTML-Part { header { } Nutzlast { } } } } Anhang 1 { header { } Nutzlast { } } ... Anhang N { header { } Nutzlast { } } } ~~~ * Jede Ebene (Einzugstiefe) braucht hierbei einen eigenen Boudary! * Außerdem kannst Du, weil in Mails nur ASCII erlaubt ist, auch das HTML mit base64 kodieren, musst das dann aber angeben. * Und noch etwas: in Mails dürfen Zeilen keine 1000 Zeichen lang sein. Üblich ist es, diese nach 77 Zeichen umzubrechen. Das betrifft insbesondere die bas64-kodierten Teile, die müssen nach der Kodierung noch umgebrochen werden, beim Dekodieren muss das empfangende Programm dann nichts machen, weil alle (mir bekannten) Base64-Dekodierer Zeilenumbrüche im Input ignorieren, weil die ja kodiert sind. * Und vermeide, wenn Du quoted-printable verwendest, in der Nutzlast Zeilen, die nur aus einem Punkt bestehen. Das signalisiert das Ende des Mails... **Literatur:** <https://www.rfc-editor.org/rfc/rfc5322> (Als Beginn)
Ja. Das Mail ist „kaputt“. bearbeitet von Raketenwilli 08.02.2023 22:59 > ~~~ > `Return-Path: <bstastatur@gmail.com> > Received: from PCMartin (p578a9728.dip0.t-ipconnect.de. [87.138.151.40]) > by smtp.gmail.com with ESMTPSA id d3-20020a056000114300b002c3f9404c45sm2346701wrx.7.2023.02.08.04.22.18 > for <bstastatur@gmail.com> > (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); > Wed, 08 Feb 2023 04:22:19 -0800 (PST) > From: <bstastatur@gmail.com> > To: <bstastatur@gmail.com> > Subject: Testmail > Date: Wed, 8 Feb 2023 13:16:15 +0100 > Message-ID: <047701d93bb7$24e4d210$6eae7630$@gmail.com> > MIME-Version: 1.0 > Content-Type: multipart/mixed; > boundary="----=_NextPart_000_0478_01D93BBF.86B37340" > # Geraffel > ~~~ Ja. Es hilft tatsächlich - weil ich nun sehe, was fehlt. Nämlich genau das, was ich oben aufgeführt habe. Generell ist das erzeugte Mail also „kaputt“. Du musst in der Dok zu Deiner Outlook-DLL suchen, wie man - den oder die Empfänger (auch CC, BCC) - den Absender, den oder die Empfänger der Antwort - das Subjekt - die Ankündigung des Multipart-Teils - die Ankündigung des Mixed-Teils - den Text-Teil - den HTML-Teil (wegen dieser Teile heisst es ja "multipart/mixed") - die Ankündigung der übrigen Anhänge - die übrigen Anhänge selbst beifügt. Bei einem Content-Type: `multipart/mixed;` schließt sich als nächstes ein Plain-Text-Teil an (mit entsprechendem Header). **Wenn man ein KORREKTES Mail mit Text, HTML und Anhängen „von Hand“ machen will..., dann sieht das im Kern so aus:** ~~~ Content-Type: multipart/mixed; boundary="Boundary_AAAAA" -- Boundary_AAAAA" Content-Type: multipart/alternative; boundary="Boundary_BBBBB" --Boundary_BBBBB Content-Type: text/plain;charset=UTF-8 Content-Transfer-Encoding: quoted-printable Hier die Nachricht im Text-Format für Mailempfänger, welche kein HTML empfangen oder darstellen können oder das bewusst nicht wollen... --Boundary_BBBBB Content-Type: text/html;charset=UTF-8 Content-Transfer-Encoding: quoted-printable <!doctype html> <html dir="ltr" lang="de"> <h1>Hier die Nachricht im HTML-Format.</h1> <p>Denke aber an das quoted-printable </html> --Boundary_BBBBB-- --Boundary_AAAAA Content-Type: application/octet-stream; name=Datei-1.pdf Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename=Datei-1.pdf JVBERi0xLjMNCiXi48/TDQo2IDAgb2JqDQo8PA0KL1R5cGUgL1BhZ2UNCi9QYXJlbnQgMiAwIFIN YWI+XQ0KPj4NCnN0YXJ0eHJlZg0KMjU2NDE5DQolJUVPRg== --Boundary_AAAAA Content-Type: application/octet-stream; name=Datei-2.pdf Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename=Datei-2.pdf JVBERi0xLjMNCiXi48/TDQo2IDAgb2JqDQo8PA0KL1R5cGUgL1BhZ2UNCi9QYXJlbnQgMiAwIFIN YWI+XQ0KPj4NCnN0YXJ0eHJlZg0KMjU2NDE5DQolJUVPRg== --Boundary_AAAAA-- ~~~ Hinweis: Ich habe oben natürlich weder das HTML noch den Text gequotet. Du musst das aber tun- übrigens auch Subjekt und ggf. Namen bei den Adressen (from, to. replto, cc, bcc) * Beachte die "-"-Symbole **vor** und **nach** den Boundary. * Beachte deren Verschachtelung Im Prinzip hat das Mail, welches Du senden willst, folgenden Aufbau (ich lehne mich mal an Javascript bzw. PHP an um die Verschachtelung zu zeigen. ~~~ Mail { Mailheader { .... } Multipart Mixed { Multipart Alternative { Text-Part { header { } Nutzlast { } } HTML-Part { header { } Nutzlast { } } } } Anhang 1 { header { } Nutzlast { } } ... Anhang N { header { } Nutzlast { } } } ~~~ * Jede Ebene (Einzugstiefe) braucht hierbei einen eigenen Boudary! * Außerdem kannst Du, weil in Mails nur ASCII erlaubt ist, auch das HTML mit base64 kodieren, musst das dann aber angeben. * Und noch etwas: in Mails dürfen Zeilen keine 1000 Zeichen lang sein. Üblich ist es, diese nach 77 Zeichen umzubrechen. Das betrifft insbesondere die bas64-kodierten Teile, die müssen nach der Kodierung noch umgebrochen werden, beim Dekodieren muss das empfangende Programm dann nichts machen, weil alle (mir bekannten) Base64-Dekodierer Zeilenumbrüche im Input ignorieren, weil die ja kodiert sind. * Und vermeide, wenn Du quoted-printable verwendest, in der Nutzlast Zeilen, die nur aus einem Punkt bestehen. Das signalisiert das Ende des Mails... **Literatur:** <https://www.rfc-editor.org/rfc/rfc5322> (Als Beginn)
Ja. Das Mail ist „kaputt“. bearbeitet von Raketenwilli 08.02.2023 22:56 > ~~~ > `Return-Path: <bstastatur@gmail.com> > Received: from PCMartin (p578a9728.dip0.t-ipconnect.de. [87.138.151.40]) > by smtp.gmail.com with ESMTPSA id d3-20020a056000114300b002c3f9404c45sm2346701wrx.7.2023.02.08.04.22.18 > for <bstastatur@gmail.com> > (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); > Wed, 08 Feb 2023 04:22:19 -0800 (PST) > From: <bstastatur@gmail.com> > To: <bstastatur@gmail.com> > Subject: Testmail > Date: Wed, 8 Feb 2023 13:16:15 +0100 > Message-ID: <047701d93bb7$24e4d210$6eae7630$@gmail.com> > MIME-Version: 1.0 > Content-Type: multipart/mixed; > boundary="----=_NextPart_000_0478_01D93BBF.86B37340" > # Geraffel > ~~~ Ja. Es hilft tatsächlich - weil ich nun sehe, was fehlt. Nämlich genau das, was ich oben aufgeführt habe. Generell ist das erzeugte Mail also „kaputt“. Du musst in der Dok zu Deiner Outlook-DLL suchen, wie man - den oder die Empfänger (auch CC, BCC) - den Absender, den oder die Empfänger der Antwort - das Subjekt - die Ankündigung des Multipart-Teils - die Ankündigung des Mixed-Teils - den Text-Teil - den HTML-Teil (wegen dieser Teile heisst es ja "multipart/mixed" - die Ankündigung der übrigen Anhänge - die übrigen Anhänge selbst beifügt. Bei einem Content-Type: `multipart/mixed;` schließt sich als nächstes ein Plain-Text-Teil an (mit entsprechendem Header). **Wenn man ein KORREKTES Mail mit Text, HTML und Anhängen „von Hand“ machen will..., dann sieht das im Kern so aus:** ~~~ Content-Type: multipart/mixed; boundary="Boundary_AAAAA" -- Boundary_AAAAA" Content-Type: multipart/alternative; boundary="Boundary_BBBBB" --Boundary_BBBBB Content-Type: text/plain;charset=UTF-8 Content-Transfer-Encoding: quoted-printable Hier die Nachricht im Text-Format für Mailempfänger, welche kein HTML empfangen oder darstellen können oder das bewusst nicht wollen... --Boundary_BBBBB Content-Type: text/html;charset=UTF-8 Content-Transfer-Encoding: quoted-printable <!doctype html> <html dir="ltr" lang="de"> <h1>Hier die Nachricht im HTML-Format.</h1> <p>Denke aber an das quoted-printable </html> --Boundary_BBBBB-- --Boundary_AAAAA Content-Type: application/octet-stream; name=Datei-1.pdf Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename=Datei-1.pdf JVBERi0xLjMNCiXi48/TDQo2IDAgb2JqDQo8PA0KL1R5cGUgL1BhZ2UNCi9QYXJlbnQgMiAwIFIN YWI+XQ0KPj4NCnN0YXJ0eHJlZg0KMjU2NDE5DQolJUVPRg== --Boundary_AAAAA Content-Type: application/octet-stream; name=Datei-2.pdf Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename=Datei-2.pdf JVBERi0xLjMNCiXi48/TDQo2IDAgb2JqDQo8PA0KL1R5cGUgL1BhZ2UNCi9QYXJlbnQgMiAwIFIN YWI+XQ0KPj4NCnN0YXJ0eHJlZg0KMjU2NDE5DQolJUVPRg== --Boundary_AAAAA-- ~~~ Hinweis: Ich habe oben natürlich weder das HTML noch den Text gequotet. Du musst das aber tun- übrigens auch Subjekt und ggf. Namen bei den Adressen (from, to. replto, cc, bcc) * Beachte die "-"-Symbole **vor** und **nach** den Boundary. * Beachte deren Verschachtelung Im Prinzip hat das Mail, welches Du senden willst, folgenden Aufbau (ich lehne mich mal an Javascript bzw. PHP an um die Verschachtelung zu zeigen. ~~~ Mail { Mailheader { .... } Multipart Mixed { Multipart Alternative { Text-Part { header { } Nutzlast { } } HTML-Part { header { } Nutzlast { } } } } Anhang 1 { header { } Nutzlast { } } ... Anhang N { header { } Nutzlast { } } } ~~~ * Jede Ebene (Einzugstiefe) braucht hierbei einen eigenen Boudary! * Außerdem kannst Du, weil in Mails nur ASCII erlaubt ist, auch das HTML mit base64 kodieren, musst das dann aber angeben. * Und noch etwas: in Mails dürfen Zeilen keine 1000 Zeichen lang sein. Üblich ist es, diese nach 77 Zeichen umzubrechen. Das betrifft insbesondere die bas64-kodierten Teile, die müssen nach der Kodierung noch umgebrochen werden, beim Dekodieren muss das empfangende Programm dann nichts machen, weil alle (mir bekannten) Base64-Dekodierer Zeilenumbrüche im Input ignorieren, weil die ja kodiert sind. * Und vermeide, wenn Du quoted-printable verwendest, in der Nutzlast Zeilen, die nur aus einem Punkt bestehen. Das signalisiert das Ende des Mails... **Literatur:** <https://www.rfc-editor.org/rfc/rfc5322> (Als Beginn)
Ja. Das Mail ist „kaputt“. bearbeitet von Raketenwilli 08.02.2023 22:56 > ~~~ > `Return-Path: <bstastatur@gmail.com> > Received: from PCMartin (p578a9728.dip0.t-ipconnect.de. [87.138.151.40]) > by smtp.gmail.com with ESMTPSA id d3-20020a056000114300b002c3f9404c45sm2346701wrx.7.2023.02.08.04.22.18 > for <bstastatur@gmail.com> > (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); > Wed, 08 Feb 2023 04:22:19 -0800 (PST) > From: <bstastatur@gmail.com> > To: <bstastatur@gmail.com> > Subject: Testmail > Date: Wed, 8 Feb 2023 13:16:15 +0100 > Message-ID: <047701d93bb7$24e4d210$6eae7630$@gmail.com> > MIME-Version: 1.0 > Content-Type: multipart/mixed; > boundary="----=_NextPart_000_0478_01D93BBF.86B37340" > # Geraffel > ~~~ Ja. Es hilft tatsächlich - weil ich nun sehe, was fehlt. Nämlich genau das, was ich oben aufgeführt habe. Generell ist das erzeugte Mail also „kaputt“. Du musst in der Dok zu Deiner Outlook-DLL suchen, wie man - den oder die Empfänger (auch CC, BCC) - den Absender, den oder die Empfänger der Antwort - das Subjekt - die Ankündigung des Multipart-Teils - die Ankündigung des Mixed-Teils - den Text-Teil - den HTML-Teil (wegen dieser Teile heisst es ja "multipart/mixed" - die Ankündigung der übrigen Anhänge - die übrigen Anhänge selbst beifügt. Bei einem Content-Type: `multipart/mixed;` schließt sich als nächstes ein Plain-Text-Teil an (mit entsprechendem Header). ** Wenn man ein Mail mit Text, HTML und Anhängen „von Hand“ machen will..., dann sieht das im Kern so aus:** ~~~ Content-Type: multipart/mixed; boundary="Boundary_AAAAA" -- Boundary_AAAAA" Content-Type: multipart/alternative; boundary="Boundary_BBBBB" --Boundary_BBBBB Content-Type: text/plain;charset=UTF-8 Content-Transfer-Encoding: quoted-printable Hier die Nachricht im Text-Format für Mailempfänger, welche kein HTML empfangen oder darstellen können oder das bewusst nicht wollen... --Boundary_BBBBB Content-Type: text/html;charset=UTF-8 Content-Transfer-Encoding: quoted-printable <!doctype html> <html dir="ltr" lang="de"> <h1>Hier die Nachricht im HTML-Format.</h1> <p>Denke aber an das quoted-printable </html> --Boundary_BBBBB-- --Boundary_AAAAA Content-Type: application/octet-stream; name=Datei-1.pdf Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename=Datei-1.pdf JVBERi0xLjMNCiXi48/TDQo2IDAgb2JqDQo8PA0KL1R5cGUgL1BhZ2UNCi9QYXJlbnQgMiAwIFIN YWI+XQ0KPj4NCnN0YXJ0eHJlZg0KMjU2NDE5DQolJUVPRg== --Boundary_AAAAA Content-Type: application/octet-stream; name=Datei-2.pdf Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename=Datei-2.pdf JVBERi0xLjMNCiXi48/TDQo2IDAgb2JqDQo8PA0KL1R5cGUgL1BhZ2UNCi9QYXJlbnQgMiAwIFIN YWI+XQ0KPj4NCnN0YXJ0eHJlZg0KMjU2NDE5DQolJUVPRg== --Boundary_AAAAA-- ~~~ Hinweis: Ich habe oben natürlich weder das HTML noch den Text gequotet. Du musst das aber tun- übrigens auch Subjekt und ggf. Namen bei den Adressen (from, to. replto, cc, bcc) * Beachte die "-"-Symbole **vor** und **nach** den Boundary. * Beachte deren Verschachtelung Im Prinzip hat das Mail, welches Du senden willst, folgenden Aufbau (ich lehne mich mal an Javascript bzw. PHP an um die Verschachtelung zu zeigen. ~~~ Mail { Mailheader { .... } Multipart Mixed { Multipart Alternative { Text-Part { header { } Nutzlast { } } HTML-Part { header { } Nutzlast { } } } } Anhang 1 { header { } Nutzlast { } } ... Anhang N { header { } Nutzlast { } } } ~~~ * Jede Ebene (Einzugstiefe) braucht hierbei einen eigenen Boudary! * Außerdem kannst Du, weil in Mails nur ASCII erlaubt ist, auch das HTML mit base64 kodieren, musst das dann aber angeben. * Und noch etwas: in Mails dürfen Zeilen keine 1000 Zeichen lang sein. Üblich ist es, diese nach 77 Zeichen umzubrechen. Das betrifft insbesondere die bas64-kodierten Teile, die müssen nach der Kodierung noch umgebrochen werden, beim Dekodieren muss das empfangende Programm dann nichts machen, weil alle (mir bekannten) Base64-Dekodierer Zeilenumbrüche im Input ignorieren, weil die ja kodiert sind. * Und vermeide, wenn Du quoted-printable verwendest, in der Nutzlast Zeilen, die nur aus einem Punkt bestehen. Das signalisiert das Ende des Mails... **Literatur:** <https://www.rfc-editor.org/rfc/rfc5322> (Als Beginn)
Ja. Das Mail ist „kaputt“. bearbeitet von Raketenwilli 08.02.2023 22:54 > ~~~ > `Return-Path: <bstastatur@gmail.com> > Received: from PCMartin (p578a9728.dip0.t-ipconnect.de. [87.138.151.40]) > by smtp.gmail.com with ESMTPSA id d3-20020a056000114300b002c3f9404c45sm2346701wrx.7.2023.02.08.04.22.18 > for <bstastatur@gmail.com> > (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); > Wed, 08 Feb 2023 04:22:19 -0800 (PST) > From: <bstastatur@gmail.com> > To: <bstastatur@gmail.com> > Subject: Testmail > Date: Wed, 8 Feb 2023 13:16:15 +0100 > Message-ID: <047701d93bb7$24e4d210$6eae7630$@gmail.com> > MIME-Version: 1.0 > Content-Type: multipart/mixed; > boundary="----=_NextPart_000_0478_01D93BBF.86B37340" > # Geraffel > ~~~ Ja. Es hilft tatsächlich - weil ich nun sehe, was fehlt. Nämlich genau das, was ich oben aufgeführt habe. Generell ist das erzeugte Mail also „kaputt“. Du musst in der Dok zu Deiner Outlook-DLL suchen, wie man - den oder die Empfänger (auch CC, BCC) - den Absender, den oder die Empfänger der Antwort - das Subjekt - die Ankündigung des Multipart-Teils - die Ankündigung des Mixed-Teils - den Text-Teil - den HTML-Teil (wegen dieser Teile heisst es ja "multipart/mixed" - die Ankündigung der übrigen Anhänge - die übrigen Anhänge selbst beifügt. Bei einem Content-Type: `multipart/mixed;` schließt sich als nächstes ein Plain-Text-Teil an (mit entsprechendem Header). ** Wenn man ein Mail mit Text, HTML und Anhängen „von Hand“ machen will..., dann sieht das im Kern so aus:** ~~~ Content-Type: multipart/mixed; boundary="Boundary_AAAAA" -- Boundary_AAAAA" Content-Type: multipart/alternative; boundary="Boundary_BBBBB" --Boundary_BBBBB Content-Type: text/plain;charset=UTF-8 Content-Transfer-Encoding: quoted-printable Hier die Nachricht im Text-Format für Mailempfänger, welche kein HTML empfangen oder darstellen können oder das bewusst nicht wollen... --Boundary_BBBBB Content-Type: text/html;charset=UTF-8 Content-Transfer-Encoding: quoted-printable <!doctype html> <html dir="ltr" lang="de"> <h1>Hier die Nachricht im HTML-Format.</h1> <p>Denke aber an das quoted-printable </html> --Boundary_BBBBB-- --Boundary_AAAAA Content-Type: application/octet-stream; name=Datei-1.pdf Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename=Datei-1.pdf JVBERi0xLjMNCiXi48/TDQo2IDAgb2JqDQo8PA0KL1R5cGUgL1BhZ2UNCi9QYXJlbnQgMiAwIFIN YWI+XQ0KPj4NCnN0YXJ0eHJlZg0KMjU2NDE5DQolJUVPRg== --Boundary_AAAAA Content-Type: application/octet-stream; name=Datei-2.pdf Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename=Datei-2.pdf JVBERi0xLjMNCiXi48/TDQo2IDAgb2JqDQo8PA0KL1R5cGUgL1BhZ2UNCi9QYXJlbnQgMiAwIFIN YWI+XQ0KPj4NCnN0YXJ0eHJlZg0KMjU2NDE5DQolJUVPRg== --Boundary_AAAAA-- ~~~ Hinweis: Ich habe oben natürlich weder das HTML noch den Text gequotet. Du musst das aber tun- übrigens auch Subjekt und ggf. Namen bei den Adressen (from, to. replto, cc, bcc) * Beachte die "-"-Symbole **vor** und **nach** den Boundary. * Beachte deren Verschachtelung Im Prinzip hat das Mail, welches Du senden willst, folgenden Aufbau (ich lehne mich mal an Javascript bzw. PHP an um die Verschachtelung zu zeigen. ~~~ Mail { Mailheader { .... } Multipart Mixed { Multipart Alternative { Text-Part { header { } Nutzlast { } } HTML-Part { header { } Nutzlast { } } } Anhang 1 { header { } Nutzlast { } } ... Anhang N { header { } Nutzlast { } } } } ~~~ * Jede Ebene (Einzugstiefe) braucht hierbei einen eigenen Boudary! * Außerdem kannst Du, weil in Mails nur ASCII erlaubt ist, auch das HTML mit base64 kodieren, musst das dann aber angeben. * Und noch etwas: in Mails dürfen Zeilen keine 1000 Zeichen lang sein. Üblich ist es, diese nach 77 Zeichen umzubrechen. Das betrifft insbesondere die bas64-kodierten Teile, die müssen nach der Kodierung noch umgebrochen werden, beim Dekodieren muss das empfangende Programm dann nichts machen, weil alle (mir bekannten) Base64-Dekodierer Zeilenumbrüche im Input ignorieren, weil die ja kodiert sind. * Und vermeide, wenn Du quoted-printable verwendest, in der Nutzlast Zeilen, die nur aus einem Punkt bestehen. Das signalisiert das Ende des Mails... **Literatur:** <https://www.rfc-editor.org/rfc/rfc5322> (Als Beginn)
Ja. Das Mail ist „kaputt“. bearbeitet von Raketenwilli 08.02.2023 22:53 > ~~~ > `Return-Path: <bstastatur@gmail.com> > Received: from PCMartin (p578a9728.dip0.t-ipconnect.de. [87.138.151.40]) > by smtp.gmail.com with ESMTPSA id d3-20020a056000114300b002c3f9404c45sm2346701wrx.7.2023.02.08.04.22.18 > for <bstastatur@gmail.com> > (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); > Wed, 08 Feb 2023 04:22:19 -0800 (PST) > From: <bstastatur@gmail.com> > To: <bstastatur@gmail.com> > Subject: Testmail > Date: Wed, 8 Feb 2023 13:16:15 +0100 > Message-ID: <047701d93bb7$24e4d210$6eae7630$@gmail.com> > MIME-Version: 1.0 > Content-Type: multipart/mixed; > boundary="----=_NextPart_000_0478_01D93BBF.86B37340" > # Geraffel > ~~~ Ja. Es hilft tatsächlich - weil was fehlt. Nämlich genau das, was ich oben aufgeführt habe. Generell ist das erzeigte Mail kaputt. Du muss in der Dok zu Deiner Outlook-DLL suchen, wie man - den oder die Empfänger (auch CC, BCC) - den Absender, den oder die Empfänger der Antwort - das Subjekt - die Ankündigung des Multipart-Teils - den Text-Teil - den HTML-Teil (wegen dieser Teile heisst es ja "multipart/mixed" - die übrigen Anhänge beifügt. Bei einem Content-Type: `multipart/mixed;` schließt sich als nächstes ein Plain-Text-Teil an (mit entsprechendem Header). ** Wenn man ein Mail mit Text, HTML und Anhängen „von Hand“ machen will..., dann sieht das im Kern so aus:** ~~~ Content-Type: multipart/mixed; boundary="Boundary_AAAAA" -- Boundary_AAAAA" Content-Type: multipart/alternative; boundary="Boundary_BBBBB" --Boundary_BBBBB Content-Type: text/plain;charset=UTF-8 Content-Transfer-Encoding: quoted-printable Hier die Nachricht im Text-Format für Mailempfänger, welche kein HTML empfangen oder darstellen können oder das bewusst nicht wollen... --Boundary_BBBBB Content-Type: text/html;charset=UTF-8 Content-Transfer-Encoding: quoted-printable <!doctype html> <html dir="ltr" lang="de"> <h1>Hier die Nachricht im HTML-Format.</h1> <p>Denke aber an das quoted-printable </html> --Boundary_BBBBB-- --Boundary_AAAAA Content-Type: application/octet-stream; name=Datei-1.pdf Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename=Datei-1.pdf JVBERi0xLjMNCiXi48/TDQo2IDAgb2JqDQo8PA0KL1R5cGUgL1BhZ2UNCi9QYXJlbnQgMiAwIFIN YWI+XQ0KPj4NCnN0YXJ0eHJlZg0KMjU2NDE5DQolJUVPRg== --Boundary_AAAAA Content-Type: application/octet-stream; name=Datei-2.pdf Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename=Datei-2.pdf JVBERi0xLjMNCiXi48/TDQo2IDAgb2JqDQo8PA0KL1R5cGUgL1BhZ2UNCi9QYXJlbnQgMiAwIFIN YWI+XQ0KPj4NCnN0YXJ0eHJlZg0KMjU2NDE5DQolJUVPRg== --Boundary_AAAAA-- ~~~ Hinweis: Ich habe oben natürlich weder das HTML noch den Text gequotet. Du musst das aber tun- übrigens auch Subjekt und ggf. Namen bei den Adressen (from, to. replto, cc, bcc) * Beachte die "-"-Symbole **vor** und **nach** den Boundary. * Beachte deren Verschachtelung Im Prinzip hat das Mail, welches Du senden willst, folgenden Aufbau (ich lehne mich mal an Javascript bzw. PHP an um die Verschachtelung zu zeigen. ~~~ Mail { Mailheader { .... } Multipart Mixed { Multipart Alternative { Text-Part { ... } HTML-Part { ... } } Anhang 1 { ... } ... Anhang N { ... } } } ~~~ * Jede Ebene (Einzugstiefe) braucht hierbei einen eigenen Boudary! * Außerdem kannst Du, weil in Mails nur ASCII erlaubt ist, auch das HTML mit base64 kodieren, musst das dann aber angeben. * Und noch etwas: in Mails dürfen Zeilen keine 1000 Zeichen lang sein. Üblich ist es, diese nach 77 Zeichen umzubrechen. Das betrifft insbesondere die bas64-kodierten Teile, die müssen nach der Kodierung noch umgebrochen werden, beim Dekodieren muss das empfangende Programm dann nichts machen, weil alle (mir bekannten) Base64-Dekodierer Zeilenumbrüche im Input ignorieren, weil die ja kodiert sind. * Und vermeide, wenn Du quoted-printable verwendest, in der Nutzlast Zeilen, die nur aus einem Punkt bestehen. Das signalisiert das Ende des Mails... **Literatur:** <https://www.rfc-editor.org/rfc/rfc5322> (Als Beginn)
Ja. Das Mail ist „kaputt“. bearbeitet von Raketenwilli 08.02.2023 22:46 > ~~~ > `Return-Path: <bstastatur@gmail.com> > Received: from PCMartin (p578a9728.dip0.t-ipconnect.de. [87.138.151.40]) > by smtp.gmail.com with ESMTPSA id d3-20020a056000114300b002c3f9404c45sm2346701wrx.7.2023.02.08.04.22.18 > for <bstastatur@gmail.com> > (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); > Wed, 08 Feb 2023 04:22:19 -0800 (PST) > From: <bstastatur@gmail.com> > To: <bstastatur@gmail.com> > Subject: Testmail > Date: Wed, 8 Feb 2023 13:16:15 +0100 > Message-ID: <047701d93bb7$24e4d210$6eae7630$@gmail.com> > MIME-Version: 1.0 > Content-Type: multipart/mixed; > boundary="----=_NextPart_000_0478_01D93BBF.86B37340" > # Geraffel > ~~~ Ja. Es hilft tatsächlich - weil was fehlt. Nämlich genau das, was ich oben aufgeführt habe. Generell ist das erzeigte Mail kaputt. Du muss in der Dok zu Deiner Outlook-DLL suchen, wie man - den oder die Empfänger (auch CC, BCC) - den Absender, den oder die Empfänger der Antwort - das Subjekt - die Ankündigung des Multipart-Teils - den Text-Teil - den HTML-Teil (wegen dieser Teile heisst es ja "multipart/mixed" - die übrigen Anhänge beifügt. Bei einem Content-Type: `multipart/mixed;` schließt sich als nächstes ein Plain-Text-Teil an (mit entsprechendem Header). ** Wenn man ein Mail mit Text, HTML und Anhängen „von Hand“ machen will..., dann sieht das im Kern so aus:** ~~~ Content-Type: multipart/mixed; boundary="Boundary_AAAAA" -- Boundary_AAAAA" Content-Type: multipart/alternative; boundary="Boundary_BBBBB" --Boundary_BBBBB Content-Type: text/plain;charset=UTF-8 Content-Transfer-Encoding: quoted-printable Hier die Nachricht im Text-Format für Mailempfänger, welche kein HTML empfangen oder darstellen können oder das bewusst nicht wollen... --Boundary_BBBBB Content-Type: text/html;charset=UTF-8 Content-Transfer-Encoding: quoted-printable <!doctype html> <html dir="ltr" lang="de"> <h1>Hier die Nachricht im HTML-Format.</h1> <p>Denke aber an das quoted-printable </html> --Boundary_BBBBB-- --Boundary_AAAAA Content-Type: application/octet-stream; name=Datei-1.pdf Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename=Datei-1.pdf JVBERi0xLjMNCiXi48/TDQo2IDAgb2JqDQo8PA0KL1R5cGUgL1BhZ2UNCi9QYXJlbnQgMiAwIFIN YWI+XQ0KPj4NCnN0YXJ0eHJlZg0KMjU2NDE5DQolJUVPRg== --Boundary_AAAAA Content-Type: application/octet-stream; name=Datei-2.pdf Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename=Datei-2.pdf JVBERi0xLjMNCiXi48/TDQo2IDAgb2JqDQo8PA0KL1R5cGUgL1BhZ2UNCi9QYXJlbnQgMiAwIFIN YWI+XQ0KPj4NCnN0YXJ0eHJlZg0KMjU2NDE5DQolJUVPRg== --Boundary_AAAAA-- ~~~ Hinweis: Ich habe oben natürlich weder das HTML noch den Text gequotet. Du musst das aber tun- übrigens auch Subjekt und ggf. Namen bei den Adressen (from, to. replto, cc, bcc) * Beachte die "-"-Symbole **vor** und **nach** den Boundary. * Beachte deren Verschachtelung Außerdem kannst Du, weil in Mails nur ASCII erlaubt ist, auch das HTML mit base64 kodieren, musst das dann aber angeben. Und noch etwas: in Mails dürfen Zeilen keine 1000 Zeichen lang sein. Üblich ist es, diese nach 77 Zeichen umzubrechen. Das betrifft insbesondere die bas64-kodierten Teile, die müssen nach der Kodierung umgebrochen werden,bei Dekodieren muss das empfangende Programm dann nichts machen, weil alle (mir bekannten) Base64-Dekodierer Zeilenumbrüche ignorieren. Und vermeide, wenn Du quoted-printable verwendest, in der Nutzlast Zeilen, die nur aus einem Punkt bestehen. Das signalisiert das Ende des Mails... **Literatur:** <https://www.rfc-editor.org/rfc/rfc5322> (Als Beginn)
Frage zu selfhtml Beispiel "Grafik/Grafiken mit Data-URI" bearbeitet von Raketenwilli 08.02.2023 22:40 > ~~~ > `Return-Path: <bstastatur@gmail.com> > Received: from PCMartin (p578a9728.dip0.t-ipconnect.de. [87.138.151.40]) > by smtp.gmail.com with ESMTPSA id d3-20020a056000114300b002c3f9404c45sm2346701wrx.7.2023.02.08.04.22.18 > for <bstastatur@gmail.com> > (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); > Wed, 08 Feb 2023 04:22:19 -0800 (PST) > From: <bstastatur@gmail.com> > To: <bstastatur@gmail.com> > Subject: Testmail > Date: Wed, 8 Feb 2023 13:16:15 +0100 > Message-ID: <047701d93bb7$24e4d210$6eae7630$@gmail.com> > MIME-Version: 1.0 > Content-Type: multipart/mixed; > boundary="----=_NextPart_000_0478_01D93BBF.86B37340" > # Geraffel > ~~~ Ja. Es hilft tatsächlich - weil was fehlt. Nämlich genau das, was ich oben aufgeführt habe. Generell ist das erzeigte Mail kaputt. Du muss in der Dok zu Deiner Outlook-DLL suchen, wie man - den oder die Empfänger (auch CC, BCC) - den Absender, den oder die Empfänger der Antwort - das Subjekt - die Ankündigung des Multipart-Teils - den Text-Teil - den HTML-Teil (wegen dieser Teile heisst es ja "multipart/mixed" - die übrigen Anhänge beifügt. Bei einem Content-Type: `multipart/mixed;` schließt sich als nächstes ein Plain-Text-Teil an (mit entsprechendem Header). ** Wenn man ein Mail mit Text, HTML und Anhängen „von Hand“ machen will..., dann sieht das im Kern so aus:*** ~~~ Content-Type: multipart/mixed; boundary="Boundary_AAAAA" Content-Type: multipart/alternative; boundary="Boundary_BBBBB" --Boundary_BBBBB Content-Type: text/plain;charset=UTF-8 Content-Transfer-Encoding: quoted-printable Hier die Nachricht im Text-Format für Mailempfänger, welche kein HTML empfangen oder darstellen können oder das bewusst nicht wollen... --Boundary_BBBBB Content-Type: text/html;charset=UTF-8 Content-Transfer-Encoding: quoted-printable <!doctype html> <html dir="ltr" lang="de"> <h1>Hier die Nachricht im HTML-Format.</h1> <p>Denke aber an das quoted-printable </html> --Boundary_BBBBB-- --Boundary_AAAAA Content-Type: application/octet-stream; name=Datei-1.pdf Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename=Datei-1.pdf JVBERi0xLjMNCiXi48/TDQo2IDAgb2JqDQo8PA0KL1R5cGUgL1BhZ2UNCi9QYXJlbnQgMiAwIFIN YWI+XQ0KPj4NCnN0YXJ0eHJlZg0KMjU2NDE5DQolJUVPRg== --Boundary_AAAAA Content-Type: application/octet-stream; name=Datei-2.pdf Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename=Datei-2.pdf JVBERi0xLjMNCiXi48/TDQo2IDAgb2JqDQo8PA0KL1R5cGUgL1BhZ2UNCi9QYXJlbnQgMiAwIFIN YWI+XQ0KPj4NCnN0YXJ0eHJlZg0KMjU2NDE5DQolJUVPRg== --Boundary_AAAAA-- ~~~ Hinweis: Ich habe oben natürlich weder das HTML noch den Text gequotet. Du musst das aber tun- übrigens auch Subjekt und ggf. Namen bei den Adressen (from, to. replto, cc, bcc) * Beachte die "-"-Symbole **vor** und **nach** den Boundary. * Beachte deren Verschachtelung Außerdem kannst Du, weil in Mails nur ASCII erlaubt ist, auch das HTML mit base64 kodieren, musst das dann aber angeben. Und noch etwas: in Mails dürfen Zeilen keine 1000 Zeichen lang sein. Üblich ist es, diese nach 77 Zeichen umzubrechen. Das betrifft insbesondere die bas64-kodierten Teile, die müssen nach der Kodierung umgebrochen werden,bei Dekodieren muss das empfangende Programm dann nichts machen, weil alle (mir bekannten) Base64-Dekodierer Zeilenumbrüche ignorieren. Und vermeide, wenn Du quoted-printable verwendest, in der Nutzlast Zeilen, die nur aus einem Punkt bestehen. Das signalisiert das Ende des Mails... **Literatur:** <https://www.rfc-editor.org/rfc/rfc5322> (Als Beginn)
nicht angemeldet nicht angemeldet
