diff --git a/main.go b/main.go
index 438a38a..0062fa9 100644
--- a/main.go
+++ b/main.go
@@ -21,6 +21,8 @@ type DB map[string]dns_entry
 
 var D map[string]dns_entry
 
+var DEBUG bool = false
+
 type dns_entry struct {
 	Dns      string `json:"dns"`
 	Ipv4     string `json:"ipv4"`
@@ -35,14 +37,14 @@ func writeToFile(filename string, data DB) error {
 	// JSON konvertieren
 	jsonData, err := json.MarshalIndent(data, "", "  ")
 	if err != nil {
-		fmt.Println("Fehler beim Serialisieren: ", err)
+		fmt.Println("!", "Fehler beim Serialisieren: ", err)
 		return err
 	}
 
 	// Datei öffnen/erstellen
 	err = os.WriteFile(filename, jsonData, 0644)
 	if err != nil {
-		fmt.Println("Fehler beim Schreiben der Datei: ", err)
+		fmt.Println("!", "Fehler beim Schreiben der Datei: ", err)
 		return err
 	}
 
@@ -54,7 +56,7 @@ func readFromFile(filename string) (DB, error) {
 	// Datei lesen
 	jsonData, err := os.ReadFile(filename)
 	if err != nil {
-		fmt.Println("Fehler beim Lesen der Datei: ", err)
+		fmt.Println("!", "Fehler beim Lesen der Datei: ", err)
 		return nil, err
 	}
 
@@ -62,7 +64,7 @@ func readFromFile(filename string) (DB, error) {
 	var data DB
 	err = json.Unmarshal(jsonData, &data)
 	if err != nil {
-		fmt.Println("Fehler beim Parsen von JSON: ", err)
+		fmt.Println("!", "Fehler beim Parsen von JSON: ", err)
 		return nil, err
 	}
 
@@ -128,7 +130,7 @@ func handler(w http.ResponseWriter, r *http.Request) {
 
 	if strings.EqualFold(Dns, "") || strings.EqualFold(Ip, "") || strings.EqualFold(User, "") || strings.EqualFold(Token, "") {
 		/* strings.ToLower(Dns) != strings.ToLower("") && strings.ToLower(Ip) != strings.ToLower("") && strings.ToLower(User) != strings.ToLower("") && strings.ToLower(Token) != strings.ToLower("")*/
-		fmt.Println("Eintrag unvollständig: ", D[Dns])
+		fmt.Println("!", "Eintrag unvollständig: ", D[Dns])
 		w.WriteHeader(200)
 		w.Write([]byte("nochg"))
 
@@ -137,33 +139,33 @@ func handler(w http.ResponseWriter, r *http.Request) {
 		if entry, exists := D[Dns+"."]; exists {
 			if User == entry.User && VerifyToken(Token, entry.Token) {
 				D[Dns+"."] = dns_entry{Dns: Dns, Ipv4: Ip, Ipv6: Ip6, User: User, Token: entry.Token, LastSeen: time.Now().String()}
-				fmt.Println("Eintrag aktualisiert: ", entry, D[Dns+"."])
+				fmt.Println("~", "Eintrag aktualisiert: ", entry, D[Dns+"."])
 				// Datei speichern
 				filename := "/data/data.json"
 				err := writeToFile(filename, D)
 				if err != nil {
-					fmt.Println("Fehler beim Schreiben:", err)
+					fmt.Println("!", "Fehler beim Schreiben:", err)
 					return
 				}
-				fmt.Println("Daten erfolgreich in Datei geschrieben.")
+				fmt.Println("~", "Daten erfolgreich in Datei geschrieben.")
 				w.WriteHeader(200)
 				w.Write([]byte("good"))
 			} else {
-				fmt.Println("Eintrag aktualisieren abgelehnt (Benutzer/Passwort ungültig): ", entry, D[Dns])
+				fmt.Println("!", "Eintrag aktualisieren abgelehnt (Benutzer/Passwort ungültig): ", entry, D[Dns])
 				w.WriteHeader(200)
 				w.Write([]byte("nochg"))
 			}
 		} else {
 			D[Dns+"."] = dns_entry{Dns: Dns, Ipv4: Ip, Ipv6: Ip6, User: User, Token: HashToken(Token), LastSeen: time.Now().String()}
-			fmt.Println("Eintrag erstellt: ", entry, D[Dns+"."])
+			fmt.Println("~", "Eintrag erstellt: ", entry, D[Dns+"."])
 			// Datei speichern
 			filename := "/data/data.json"
 			err := writeToFile(filename, D)
 			if err != nil {
-				fmt.Println("Fehler beim Schreiben:", err)
+				fmt.Println("!", "Fehler beim Schreiben:", err)
 				return
 			}
-			fmt.Println("Daten erfolgreich in Datei geschrieben.")
+			fmt.Println("~", "Daten erfolgreich in Datei geschrieben.")
 			w.WriteHeader(200)
 			w.Write([]byte("good"))
 		}
@@ -172,7 +174,15 @@ func handler(w http.ResponseWriter, r *http.Request) {
 }
 
 func handlerIP(w http.ResponseWriter, r *http.Request) {
-
+	remoteIP := r.Header.Get("X-Forwarded-For")
+	if remoteIP == "" {
+		remoteIP = r.RemoteAddr // Fallback, wenn kein Header gesetzt ist
+	}
+	if DEBUG {
+		fmt.Println("~", "Remote-IP:", remoteIP)
+	}
+	w.WriteHeader(200)
+	w.Write([]byte(remoteIP))
 }
 
 func handleDNSRequest(w dns.ResponseWriter, r *dns.Msg) {
@@ -190,10 +200,14 @@ func handleDNSRequest(w dns.ResponseWriter, r *dns.Msg) {
 			if exists {
 				rr, err := dns.NewRR(q.Name + " A " + ip.Ipv4)
 				if err == nil {
-					fmt.Println("Antwort (IPv4):", rr, q.Name)
+					if DEBUG {
+						fmt.Println("~", "handleDNSRequest", "case dns.TypeA", "D[q.Name]", D[q.Name], "q.Name", q.Name)
+					}
 					msg.Answer = append(msg.Answer, rr)
 				} else {
-					fmt.Println("Fehler beim Erstellen der Antwort (4):", err)
+					if DEBUG {
+						fmt.Println("!", "handleDNSRequest", "case dns.TypeA", "IPv4", "error", err)
+					}
 				}
 			}
 		case dns.TypeAAAA: // IPv6-Anfrage
@@ -202,30 +216,46 @@ func handleDNSRequest(w dns.ResponseWriter, r *dns.Msg) {
 			if exists && !strings.EqualFold(ip.Ipv6, "") {
 				rr, err := dns.NewRR(q.Name + " AAAA " + ip.Ipv6)
 				if err == nil {
-					fmt.Println("Antwort (IPv6):", rr, q.Name)
+					if DEBUG {
+						fmt.Println("~", "handleDNSRequest", "case dns.TypeAAAA", "D[q.Name]", D[q.Name], "q.Name", q.Name)
+					}
 					msg.Answer = append(msg.Answer, rr)
 				} else {
-					fmt.Println("Fehler beim Erstellen der Antwort (6):", err)
+					if DEBUG {
+						fmt.Println("!", "handleDNSRequest", "case dns.TypeAAAA", "IPv6", "error", err)
+					}
 				}
 			}
 		case dns.TypePTR:
 			for a, b := range D {
 
 				iptocheck := reverseString(b.Ipv4)
-				fmt.Println(iptocheck, q.Name)
 				if iptocheck+".in-addr.arpa." == q.Name {
 					rr, err := dns.NewRR(q.Name + " PTR " + a)
 					if err == nil {
+						if DEBUG {
+							fmt.Println("~", "handleDNSRequest", "case dns.TypePTR", "IPv4", "found match", a, b)
+						}
 						msg.Answer = append(msg.Answer, rr)
+					} else {
+						if DEBUG {
+							fmt.Println("!", "handleDNSRequest", "case dns.TypePTR", "IPv4", "error", err)
+						}
 					}
 				}
 
 				ip6tocheck, _ := IPv6ToPTR(b.Ipv6)
-				fmt.Println(ip6tocheck, q.Name)
 				if ip6tocheck == q.Name {
 					rr, err := dns.NewRR(q.Name + " PTR " + a)
 					if err == nil {
+						if DEBUG {
+							fmt.Println("~", "handleDNSRequest", "case dns.TypePTR", "IPv6", "found match", a, b)
+						}
 						msg.Answer = append(msg.Answer, rr)
+					} else {
+						if DEBUG {
+							fmt.Println("!", "handleDNSRequest", "case dns.TypePTR", "IPv6", "error", err)
+						}
 					}
 				}
 			}
@@ -239,15 +269,15 @@ func handleDNSRequest(w dns.ResponseWriter, r *dns.Msg) {
 }
 
 func prepareExit() {
-	fmt.Println("Running exit tasks...")
+	fmt.Println("~", "Running exit tasks...")
 
-	fmt.Println("Exit completed.")
+	fmt.Println("~", "Exit completed.")
 }
 
 func StopServer(e error) {
-	fmt.Println("Stopping server...")
+	fmt.Println("~", "Stopping server...")
 	prepareExit()
-	fmt.Println("Server stopped!")
+	fmt.Println("~", "Server stopped!")
 }
 
 func main() {
@@ -257,16 +287,20 @@ func main() {
 	HTTP_TLS_PRIVATEKEY := os.Getenv("HTTP_TLS_PRIVATEKEY")
 	HTTP_TLS_CERTIFICATE := os.Getenv("HTTP_TLS_CERTIFICATE")
 
+	if os.Getenv("DEBUG") == "1" {
+		DEBUG = true
+	}
+
 	if strings.EqualFold(HTTP_TLS, "") || strings.EqualFold(HTTP_PORT, "") || strings.EqualFold(HTTP_TLS_PRIVATEKEY, "") || strings.EqualFold(HTTP_TLS_CERTIFICATE, "") {
-		fmt.Println("No port or mode defined. Fallback to TLS=0 & Port=8080")
-		fmt.Println("ENV's: [HTTP_PORT=8080|443], [HTTP_TLS=0|1],[HTTP_TLS_PRIVATEKEY=#],[HTTP_TLS_CERTIFICATE=#]")
-		fmt.Println("Remember to set unused ENVs like [HTTP_TLS_PRIVATEKEY] or [HTTP_TLS_CERTIFICATE] to '#'")
+		fmt.Println("~", "No port or mode defined. Fallback to TLS=0 & Port=8080")
+		fmt.Println("~", "ENV's: [HTTP_PORT=8080|443], [HTTP_TLS=0|1],[HTTP_TLS_PRIVATEKEY=#],[HTTP_TLS_CERTIFICATE=#]")
+		fmt.Println("~", "Remember to set unused ENVs like [HTTP_TLS_PRIVATEKEY] or [HTTP_TLS_CERTIFICATE] to '#'")
 		HTTP_PORT = "8080"
 		HTTP_TLS = "0"
 		HTTP_TLS_CERTIFICATE = ""
 		HTTP_TLS_PRIVATEKEY = ""
 	} else {
-		fmt.Println("Port and mode defined.")
+		fmt.Println("~", "Port and mode defined.")
 	}
 
 	// Signal-Kanal einrichten
@@ -276,7 +310,7 @@ func main() {
 	// Goroutine, die auf Signale wartet
 	go func() {
 		<-stop
-		fmt.Println("Received stop signal")
+		fmt.Println("~", "Received stop signal")
 		prepareExit()
 		os.Exit(0)
 	}()
@@ -286,9 +320,9 @@ func main() {
 	filename := "/data/data.json"
 	readData, err := readFromFile(filename)
 	if err != nil {
-		fmt.Println("Fehler beim Lesen:", err)
+		fmt.Println("!", "Fehler beim Lesen:", err)
 	} else {
-		fmt.Println("Daten erfolgreich aus Datei gelesen.")
+		fmt.Println("~", "Daten erfolgreich aus Datei gelesen.")
 		D = readData
 	}
 
@@ -301,7 +335,7 @@ func main() {
 
 	serverUDP := &dns.Server{Addr: ":53", Net: "udp"}
 	go func() {
-		log.Println("Starting DNS server on UDP :53")
+		log.Println("~", "Starting DNS server on UDP :53")
 		if err := serverUDP.ListenAndServe(); err != nil {
 			log.Fatalf("Failed to start UDP server: %v", err)
 		}
@@ -309,7 +343,7 @@ func main() {
 
 	serverTCP := &dns.Server{Addr: ":53", Net: "tcp"}
 	go func() {
-		log.Println("Starting DNS server on TCP :53")
+		log.Println("~", "Starting DNS server on TCP :53")
 		if err := serverTCP.ListenAndServe(); err != nil {
 			log.Fatalf("Failed to start TCP server: %v", err)
 		}
@@ -317,13 +351,13 @@ func main() {
 
 	/* HTTP-PART */
 
-	fmt.Println("Server listening on port :" + HTTP_PORT)
+	fmt.Println("~", "Server listening on port :"+HTTP_PORT)
 	if HTTP_TLS == "0" {
-		fmt.Println("Protocol is http (insecure)")
+		fmt.Println("~", "Protocol is http (insecure)")
 		StopServer(http.ListenAndServe(":"+HTTP_PORT, nil))
 	}
 	if HTTP_TLS == "1" {
-		fmt.Println("Protocol is https (secure)")
+		fmt.Println("~", "Protocol is https (secure)")
 		StopServer(http.ListenAndServeTLS(":"+HTTP_PORT, HTTP_TLS_CERTIFICATE, HTTP_TLS_PRIVATEKEY, nil))
 	}