URL Debugging wegen nichtaufnahme von Anfragen

Reviewed-on: #6

Dockerfile

@@ -1,4 +1,7 @@
 FROM golang:1.23.3
+RUN mkdir /data
+RUN apt update && apt install net-tools nano -y
+COPY data/* /data
 WORKDIR /app
 COPY go.mod go.sum ./
 RUN go mod download

data/data.json

@@ -0,0 +1,10 @@
+{
+  "friedhof8.hilden.de.": {
+    "dns": "friedhof8.hilden.de",
+    "ipv4": "1.1.1.2",
+    "ipv6": "2001::5b:41",
+    "user": "friedhof",
+    "token": "ef797c8118f02dfb649607dd5d3f8c7623048c9c063d532cc95c5ed7a898a64f",
+    "lastseen": "2025-01-14 06:53:45.7690632 +0100 CET m=+27.298316601"
+  }
+}

go.mod

@@ -1,3 +1,13 @@
 module git.send.nrw/sendnrw/fritzbox_dyndns
 
 go 1.23.1
+
+require github.com/miekg/dns v1.1.62
+
+require (
+	golang.org/x/mod v0.18.0 // indirect
+	golang.org/x/net v0.27.0 // indirect
+	golang.org/x/sync v0.7.0 // indirect
+	golang.org/x/sys v0.22.0 // indirect
+	golang.org/x/tools v0.22.0 // indirect
+)

go.sum

@@ -0,0 +1,12 @@
+github.com/miekg/dns v1.1.62 h1:cN8OuEF1/x5Rq6Np+h1epln8OiyPWV+lROx9LxcGgIQ=
+github.com/miekg/dns v1.1.62/go.mod h1:mvDlcItzm+br7MToIKqkglaGhlFMHJ9DTNNWONWXbNQ=
+golang.org/x/mod v0.18.0 h1:5+9lSbEzPSdWkH32vYPBwEpX8KwDbM52Ud9xBUvNlb0=
+golang.org/x/mod v0.18.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
+golang.org/x/net v0.27.0 h1:5K3Njcw06/l2y9vpGCSdcxWOYHOUk3dVNGDXN+FvAys=
+golang.org/x/net v0.27.0/go.mod h1:dDi0PyhWNoiUOrAS8uXv/vnScO4wnHQO4mj9fn/RytE=
+golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
+golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sys v0.22.0 h1:RI27ohtqKCnwULzJLqkv897zojh5/DwS/ENaMzUOaWI=
+golang.org/x/sys v0.22.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/tools v0.22.0 h1:gqSGLZqv+AI9lIQzniJ0nZDRG5GBPsSi+DRNHWNz6yA=
+golang.org/x/tools v0.22.0/go.mod h1:aCwcsjqvq7Yqt6TNyX7QMU2enbQ/Gt0bo6krSeEri+c=

main.go

@@ -1,21 +1,39 @@
 package main
 
 import (
+	"crypto/sha256"
+	"encoding/hex"
 	"encoding/json"
 	"fmt"
+	"log"
+	"net"
 	"net/http"
 	"os"
+	"os/signal"
 	"strings"
+	"syscall"
 	"time"
+
+	"github.com/miekg/dns"
 )
 
+/*
+
+DNS-Status-Code übersicht: https://pkg.go.dev/github.com/miekg/dns@v1.1.62#TypeSOA
+
+*/
+
 type DB map[string]dns_entry
 
 var D map[string]dns_entry
 
+var DEBUG bool = false
+var ERRORLOG_FILE string = "/data/error.log"
+
 type dns_entry struct {
 	Dns      string `json:"dns"`
-	Ip       string `json:"ip"`
+	Ipv4     string `json:"ipv4"`
+	Ipv6     string `json:"ipv6"`
 	User     string `json:"user"`
 	Token    string `json:"token"`
 	LastSeen string `json:"lastseen"`
@@ -26,14 +44,14 @@ func writeToFile(filename string, data DB) error {
 	// JSON konvertieren
 	jsonData, err := json.MarshalIndent(data, "", "  ")
 	if err != nil {
-		fmt.Println("Fehler beim Serialisieren: ", err)
+		WriteLog("!", "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)
+		WriteLog("!", "Fehler beim Schreiben der Datei: ", err)
 		return err
 	}
 
@@ -45,7 +63,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)
+		WriteLog("!", "Fehler beim Lesen der Datei: ", err)
 		return nil, err
 	}
 
@@ -53,16 +71,66 @@ 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)
+		WriteLog("!", "Fehler beim Parsen von JSON: ", err)
 		return nil, err
 	}
 
 	return data, nil
 }
 
+// HashToken hashes a token using SHA-256.
+func HashToken(token string) string {
+	hash := sha256.Sum256([]byte(token))
+	return hex.EncodeToString(hash[:])
+}
+
+// VerifyToken compares a plaintext token with a stored hash.
+func VerifyToken(token, storedHash string) bool {
+	return HashToken(token) == storedHash
+}
+
+func reverseString(s string) string {
+	// Konvertiere den String in eine Rune-Slice, um Unicode-Zeichen zu unterstützen
+	runes := []rune(s)
+	n := len(runes)
+	// Tausche die Elemente, um den String umzudrehen
+	for i := 0; i < n/2; i++ {
+		runes[i], runes[n-1-i] = runes[n-1-i], runes[i]
+	}
+	// Konvertiere die Rune-Slice zurück in einen String
+	return string(runes)
+}
+
+func IPv6ToPTR(ipv6 string) (string, error) {
+	// Parse the IPv6 address to validate it
+	parsedIP := net.ParseIP(ipv6)
+	if parsedIP == nil || parsedIP.To16() == nil || parsedIP.To4() != nil {
+		return "", fmt.Errorf("invalid IPv6 address: %s", ipv6)
+	}
+
+	// Expand the IPv6 address to its full form
+	expanded := parsedIP.To16()
+
+	// Convert to a reversed nibble format for PTR
+	var nibbles []string
+	for i := len(expanded) - 1; i >= 0; i-- {
+		hexByte := fmt.Sprintf("%02x", expanded[i])
+		// Add the nibbles in reverse order
+		nibbles = append(nibbles, string(hexByte[1]), string(hexByte[0]))
+	}
+
+	// Join the nibbles with dots and append the reverse domain
+	reversed := strings.Join(nibbles, ".")
+	return reversed + ".ip6.arpa.", nil
+}
+
 func handler(w http.ResponseWriter, r *http.Request) {
+
+	WriteLog("~", "Full-URL:", r.URL.String())
+
 	Dns := r.URL.Query().Get("DDNS")
 	Ip := r.URL.Query().Get("IP")
+	Ip6 := r.URL.Query().Get("IPv6")
 	User := r.URL.Query().Get("USER")
 	Token := r.URL.Query().Get("TOKEN")
 
@@ -70,44 +138,49 @@ func handler(w http.ResponseWriter, r *http.Request) {
 		D = make(map[string]dns_entry)
 	}
 
+	if strings.Contains(Ip6, ".") {
+		WriteLog("!", "IPv6 nicht möglich (IP-Version-Mismatch):", Ip6, "eventuell eine IPv4-Adresse?")
+		Ip6 = ""
+	}
+
 	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])
+		WriteLog("!", "Eintrag unvollständig: ", D[Dns])
 		w.WriteHeader(200)
 		w.Write([]byte("nochg"))
 
 	} else {
 
-		if entry, exists := D[Dns]; exists {
-			if User == entry.User && Token == entry.Token {
-				D[Dns] = dns_entry{Dns: Dns, Ip: Ip, User: User, Token: Token, LastSeen: time.Now().String()}
-				fmt.Println("Eintrag aktualisiert: ", entry, D[Dns])
+		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()}
+				WriteLog("~", "Eintrag aktualisiert: ", entry, D[Dns+"."])
 				// Datei speichern
-				filename := "data.json"
+				filename := "/data/data.json"
 				err := writeToFile(filename, D)
 				if err != nil {
-					fmt.Println("Fehler beim Schreiben:", err)
+					WriteLog("!", "Fehler beim Schreiben:", err)
 					return
 				}
-				fmt.Println("Daten erfolgreich in Datei geschrieben.")
+				WriteLog("~", "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])
+				WriteLog("!", "Eintrag aktualisieren abgelehnt (Benutzer/Passwort ungültig): ", entry, D[Dns])
 				w.WriteHeader(200)
 				w.Write([]byte("nochg"))
 			}
 		} else {
-			D[Dns] = dns_entry{Dns: Dns, Ip: Ip, User: User, Token: Token, LastSeen: time.Now().String()}
-			fmt.Println("Eintrag erstellt: ", entry, D[Dns])
+			D[Dns+"."] = dns_entry{Dns: Dns, Ipv4: Ip, Ipv6: Ip6, User: User, Token: HashToken(Token), LastSeen: time.Now().String()}
+			WriteLog("~", "Eintrag erstellt: ", entry, D[Dns+"."])
 			// Datei speichern
-			filename := "data.json"
+			filename := "/data/data.json"
 			err := writeToFile(filename, D)
 			if err != nil {
-				fmt.Println("Fehler beim Schreiben:", err)
+				WriteLog("!", "Fehler beim Schreiben:", err)
 				return
 			}
-			fmt.Println("Daten erfolgreich in Datei geschrieben.")
+			WriteLog("~", "Daten erfolgreich in Datei geschrieben.")
 			w.WriteHeader(200)
 			w.Write([]byte("good"))
 		}
@@ -115,27 +188,329 @@ func handler(w http.ResponseWriter, r *http.Request) {
 
 }
 
-func handlerIP(w http.ResponseWriter, r *http.Request) {
+var SysLog = []string{}
 
+func WriteLog(a ...any) error {
+	if DEBUG {
+		fmt.Println(time.Now().Format("2006-01-02_15-04-05"), a)
+	}
+	SysLog = append(SysLog, fmt.Sprintf("%s %s", time.Now().String(), a))
+	// JSON konvertieren
+	jsonData, err := json.MarshalIndent(SysLog, "", "  ")
+	if err != nil {
+		fmt.Println("!", "Fehler beim Serialisieren: ", err)
+		return err
+	}
+	// Datei öffnen/erstellen
+	err = os.WriteFile(ERRORLOG_FILE, jsonData, 0644)
+	if err != nil {
+		fmt.Println("!", "Fehler beim Schreiben der Datei: ", err)
+		return err
+	}
+	return nil
+}
+
+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 {
+		WriteLog("~", "Remote-IP:", remoteIP)
+	}
+	w.WriteHeader(200)
+	w.Write([]byte(remoteIP))
+}
+
+func handlerIPv6Pro(w http.ResponseWriter, r *http.Request) {
+	// Funktion zum Extrahieren der IP-Adresse
+	getIP := func(r *http.Request) string {
+		// Prüfen, ob X-Forwarded-For vorhanden ist (für Proxys)
+		xff := r.Header.Get("X-Forwarded-For")
+		if xff != "" {
+			// X-Forwarded-For kann mehrere IPs enthalten (Client, Proxy, etc.)
+			ips := strings.Split(xff, ",")
+			return strings.TrimSpace(ips[0])
+		}
+
+		// Prüfen, ob X-Real-IP vorhanden ist (eine alternative Proxy-Header-Option)
+		xRealIP := r.Header.Get("X-Real-IP")
+		if xRealIP != "" {
+			return xRealIP
+		}
+
+		// Fallback: RemoteAddr verwenden
+		host, _, err := net.SplitHostPort(r.RemoteAddr)
+		if err != nil {
+			return r.RemoteAddr // Falls SplitHostPort fehlschlägt, gib die Raw-Adresse zurück
+		}
+		return host
+	}
+
+	// Die IP-Adresse des Clients auslesen
+	clientIP := getIP(r)
+
+	// Prüfen, ob IPv4 oder IPv6
+	parsedIP := net.ParseIP(clientIP)
+	if parsedIP == nil {
+		http.Error(w, "Ungültige IP-Adresse", http.StatusInternalServerError)
+		return
+	}
+
+	// Ausgabe der Adresse
+	if parsedIP.To4() != nil {
+		fmt.Fprintf(w, "Client IPv4-Adresse: %s\n", clientIP)
+	} else {
+		fmt.Fprintf(w, "Client IPv6-Adresse: %s\n", clientIP)
+	}
+
+	// Optionale Ausgabe aller Header (Debugging)
+	fmt.Fprintln(w, "\nAlle HTTP-Header:")
+	for name, values := range r.Header {
+		for _, value := range values {
+			fmt.Fprintf(w, "%s: %s\n", name, value)
+		}
+	}
+}
+
+func handleDNSRequest(w dns.ResponseWriter, r *dns.Msg) {
+	// Bereite die Antwort vor
+	msg := new(dns.Msg)
+	msg.SetReply(r)
+	msg.Authoritative = true
+
+	if DEBUG {
+		WriteLog("~", "handleDNSRequest", "RemotePeer", w.RemoteAddr().String())
+	}
+
+	// Durchlaufe alle Fragen in der Anfrage
+	for _, q := range r.Question {
+		if strings.ToLower(q.Name) != q.Name {
+			if DEBUG {
+				WriteLog("!", "handleDNSRequest", "case dns.TypeANY", "strings.ToLower(q.Name) != q.Name", strings.ToLower(q.Name), q.Name)
+			}
+		}
+		switch q.Qtype {
+		case dns.TypeA: // IPv4-Anfrage
+			ip, exists := D[strings.ToLower(q.Name)]
+			if exists {
+				rr, err := dns.NewRR(strings.ToLower(q.Name) + " A " + ip.Ipv4)
+				if err == nil {
+					if DEBUG {
+						WriteLog("~", "handleDNSRequest", "case dns.TypeA", "D[q.Name]", D[strings.ToLower(q.Name)], "q.Name", strings.ToLower(q.Name))
+					}
+					msg.Answer = append(msg.Answer, rr)
+				} else {
+					if DEBUG {
+						WriteLog("!", "handleDNSRequest", "case dns.TypeA", "IPv4", "error", err)
+					}
+				}
+			} else {
+				if DEBUG {
+					WriteLog("!", "handleDNSRequest", "case dns.TypeA", "not found in D", strings.ToLower(q.Name))
+				}
+			}
+
+		case dns.TypeAAAA: // IPv6-Anfrage
+			// Beispielhafte IPv6-Adresse für Demonstration
+			ip6, exists := D[strings.ToLower(q.Name)]
+			if exists && !strings.EqualFold(ip6.Ipv6, "") {
+				rr, err := dns.NewRR(strings.ToLower(q.Name) + " AAAA " + ip6.Ipv6)
+				if err == nil {
+					if DEBUG {
+						WriteLog("~", "handleDNSRequest", "case dns.TypeAAAA", "D[q.Name]", D[strings.ToLower(q.Name)], "q.Name", strings.ToLower(q.Name))
+					}
+					msg.Answer = append(msg.Answer, rr)
+				} else {
+					if DEBUG {
+						WriteLog("!", "handleDNSRequest", "case dns.TypeAAAA", "IPv6", "error", err)
+					}
+				}
+			} else {
+				if DEBUG {
+					WriteLog("!", "handleDNSRequest", "case dns.TypeAAAA", "not found in D", strings.ToLower(q.Name))
+				}
+			}
+		case dns.TypePTR:
+			for a, b := range D {
+				iptocheck := reverseString(b.Ipv4)
+				if iptocheck+".in-addr.arpa." == strings.ToLower(q.Name) {
+					rr, err := dns.NewRR(strings.ToLower(q.Name) + " PTR " + a)
+					if err == nil {
+						if DEBUG {
+							WriteLog("~", "handleDNSRequest", "case dns.TypePTR", "IPv4", "found match", a, b)
+						}
+						msg.Answer = append(msg.Answer, rr)
+					} else {
+						if DEBUG {
+							WriteLog("!", "handleDNSRequest", "case dns.TypePTR", "IPv4", "error", err)
+						}
+					}
+				}
+
+				ip6tocheck, _ := IPv6ToPTR(b.Ipv6)
+				if ip6tocheck == strings.ToLower(q.Name) {
+					rr, err := dns.NewRR(strings.ToLower(q.Name) + " PTR " + a)
+					if err == nil {
+						if DEBUG {
+							WriteLog("~", "handleDNSRequest", "case dns.TypePTR", "IPv6", "found match", a, b)
+						}
+						msg.Answer = append(msg.Answer, rr)
+					} else {
+						if DEBUG {
+							WriteLog("!", "handleDNSRequest", "case dns.TypePTR", "IPv6", "error", err)
+						}
+					}
+				}
+			}
+		case dns.TypeANY:
+			ip, exists := D[strings.ToLower(q.Name)]
+			if exists {
+				rr, err := dns.NewRR(strings.ToLower(q.Name) + " A " + ip.Ipv4)
+				if err == nil {
+					if DEBUG {
+						WriteLog("~", "handleDNSRequest", "case dns.TypeANY", "D[q.Name]", D[strings.ToLower(q.Name)], "q.Name", strings.ToLower(q.Name))
+					}
+					msg.Answer = append(msg.Answer, rr)
+				} else {
+					if DEBUG {
+						WriteLog("!", "handleDNSRequest", "case dns.TypeANY", "IPv4", "error", err)
+					}
+				}
+			} else {
+				if DEBUG {
+					WriteLog("!", "handleDNSRequest", "case dns.TypeANY", "not found in D", strings.ToLower(q.Name))
+				}
+			}
+			// Beispielhafte IPv6-Adresse für Demonstration
+			ip6, exists := D[strings.ToLower(q.Name)]
+			if exists && !strings.EqualFold(ip6.Ipv6, "") {
+				rr, err := dns.NewRR(strings.ToLower(q.Name) + " AAAA " + ip6.Ipv6)
+				if err == nil {
+					if DEBUG {
+						WriteLog("~", "handleDNSRequest", "case dns.TypeANY", "D[q.Name]", D[strings.ToLower(q.Name)], "q.Name", strings.ToLower(q.Name))
+					}
+					msg.Answer = append(msg.Answer, rr)
+				} else {
+					if DEBUG {
+						WriteLog("!", "handleDNSRequest", "case dns.TypeANY", "IPv6", "error", err)
+					}
+				}
+			} else {
+				if DEBUG {
+					WriteLog("!", "handleDNSRequest", "case dns.TypeANY", "not found in D", strings.ToLower(q.Name))
+				}
+			}
+		default:
+			if DEBUG {
+				WriteLog("+", "unhandledDNSRequest", r.Question, strings.ToLower(q.Name), q.Qclass, q.Qtype)
+			}
+		}
+	}
+
+	// Antwort senden
+	w.WriteMsg(msg)
+}
+
+func prepareExit() {
+	WriteLog("~", "Running exit tasks...")
+	os.Rename("/data/error.log", "/data/error_"+time.Now().Format("2006-01-02_15-04-05")+".log")
+	fmt.Println("~", "Exit completed.")
+}
+
+func StopServer(e error) {
+	WriteLog("~", "Stopping server...")
+	prepareExit()
+	fmt.Println("~", "Server stopped!")
 }
 
 func main() {
+
+	HTTP_PORT := os.Getenv("HTTP_PORT")
+	HTTP_TLS := os.Getenv("HTTP_TLS") /* 1/0 */
+	HTTP_TLS_PRIVATEKEY := os.Getenv("HTTP_TLS_PRIVATEKEY")
+	HTTP_TLS_CERTIFICATE := os.Getenv("HTTP_TLS_CERTIFICATE")
+	ERRORLOG_FILE = os.Getenv("ERRORLOG_FILE")
+
+	if os.Getenv("DEBUG") == "1" {
+		DEBUG = true
+		WriteLog("~", "Debug mode enabled.")
+	}
+
+	if strings.EqualFold(HTTP_TLS, "") || strings.EqualFold(HTTP_PORT, "") || strings.EqualFold(HTTP_TLS_PRIVATEKEY, "") || strings.EqualFold(HTTP_TLS_CERTIFICATE, "") {
+		WriteLog("~", "No port or mode defined. Fallback to TLS=0 & Port=8080")
+		WriteLog("~", "ENV's: [HTTP_PORT=8080|443], [HTTP_TLS=0|1],[HTTP_TLS_PRIVATEKEY=#],[HTTP_TLS_CERTIFICATE=#]")
+		WriteLog("~", "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 = ""
+		ERRORLOG_FILE = "/data/error.log"
+	} else {
+		WriteLog("~", "Port and mode defined.")
+	}
+
+	// Signal-Kanal einrichten
+	stop := make(chan os.Signal, 1)
+	signal.Notify(stop, syscall.SIGINT, syscall.SIGTERM)
+
+	// Goroutine, die auf Signale wartet
+	go func() {
+		<-stop
+		WriteLog("~", "Received stop signal")
+		prepareExit()
+		os.Exit(0)
+	}()
+
 	D = make(map[string]dns_entry)
 	// Datei lesen
-	filename := "data.json"
+	filename := "/data/data.json"
 	readData, err := readFromFile(filename)
 	if err != nil {
-		fmt.Println("Fehler beim Lesen:", err)
+		WriteLog("!", "Fehler beim Lesen:", err)
 	} else {
-		fmt.Println("Daten erfolgreich aus Datei gelesen.")
+		WriteLog("~", "Daten erfolgreich aus Datei gelesen.")
 		D = readData
 	}
 
 	http.HandleFunc("/", handler)
 	http.HandleFunc("/ip", handlerIP)
-	fmt.Println("Server läuft auf http://*:8080")
-	srv_err := http.ListenAndServe(":8089", nil)
-	if srv_err != nil {
-		fmt.Println("Starten des Servers fehlgeschlagen!", srv_err)
+	http.HandleFunc("/ipv6", handlerIPv6Pro)
+
+	/* DNS-PART */
+
+	dns.HandleFunc(".", handleDNSRequest)
+
+	serverUDP := &dns.Server{Addr: ":53", Net: "udp"}
+	go func() {
+		log.Println("~", "Starting DNS server on UDP :53")
+		if err := serverUDP.ListenAndServe(); err != nil {
+			log.Fatalf("Failed to start UDP server: %v", err)
+		}
+	}()
+
+	serverTCP := &dns.Server{Addr: ":53", Net: "tcp"}
+	go func() {
+		log.Println("~", "Starting DNS server on TCP :53")
+		if err := serverTCP.ListenAndServe(); err != nil {
+			log.Fatalf("Failed to start TCP server: %v", err)
+		}
+	}()
+
+	/* HTTP-PART */
+
+	WriteLog("~", "Server listening on port :"+HTTP_PORT)
+	if HTTP_TLS == "0" {
+		WriteLog("~", "Protocol is http (insecure)")
+		StopServer(http.ListenAndServe(":"+HTTP_PORT, nil))
 	}
+	if HTTP_TLS == "1" {
+		WriteLog("~", "Protocol is https (secure)")
+		StopServer(http.ListenAndServeTLS(":"+HTTP_PORT, HTTP_TLS_CERTIFICATE, HTTP_TLS_PRIVATEKEY, nil))
+	}
+
+	/*srv_err := http.ListenAndServe(":8080", nil)
+	if srv_err != nil {
+		WriteLog("Starten des Servers fehlgeschlagen!", srv_err)
+	}*/
 }