diff --git a/OLD.allgemeines b/OLD.allgemeines
index dc975e5..27855b1 100644
--- a/OLD.allgemeines
+++ b/OLD.allgemeines
@@ -193023,3 +193023,32 @@
 
 
 
+Re: DE-Domaininhaber ermitteln (Vardion,  7. Jul 2020, 19:42:51):
+~#! rn=Amaryllis rt=1593425568 rg=allgemeines
+~#! tid=1593425568
+Wieso koennen sie deine Anfrage aus Datenschutzgruenden nicht weiterleiten?
+Das war doch schon bei Chriffre-Anzeigen der Standard. Das klingt fuer mich
+eher wie "kein Bock" oder "kein existierender Prozess".
+
+Vardion
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: DE-Domaininhaber ermitteln (Amaryllis,  7. Jul 2020, 21:18:41):
+~#! rn=Vardion rt=1594143771 rg=allgemeines
+~#! tid=1593425568
+Anscheinend ist dies seit der DSGVO tatschlich nicht mehr erlaubt. Man muss
+wohl ein Auskungtsersuchen mit dem "Nachweis eines berecjtigten Interesses"
+bei der Denic stellen. Sieht dann in der Praxis wohl so aus, dass man den
+Inhaber wg irgendwas verklagen muss, um an die Daten zu kommen.Bei dieser
+Taktik duerfte ihm dann aber wohl die Lust vergehen, dem Klaeger die Domain zu
+verkaufen.
+
+Ama*
+
+-----------------------------------------------------------------------------
+
+
+
diff --git a/OLD.megaschmarrn b/OLD.megaschmarrn
index d608ab0..e018027 100644
--- a/OLD.megaschmarrn
+++ b/OLD.megaschmarrn
Binary files differ
