Go: ottenere i record DNS di un dominio

In questo articolo vedremo come ottenere i record DNS di un dominio con Go.

Iniziamo importando i package richiesti:

import (
    "fmt"
    "net"
)

Abbiamo importato due package standard di Go: "fmt" per la formattazione dell'output e "net" per l'accesso alle funzioni di rete, comprese le query DNS.

Definiamo quindi una struct per memorizzare l'host (il nome del dominio) e il tipo di record DNS che si vogliamo cercare (A, CNAME, NS, MX o TXT).

type DNSQuery struct {
	Host string
	Type string
}

Creiamo ora la funzione principale del programma che esegue le query DNS. Prende in input un oggetto di tipo DNSQuery e restituisce un array di stringhe (record DNS) e un errore, se ce n'è uno.

func getRecord(record DNSQuery) ([]string, error) {
	var records []string
	recordType := record.Type
	domain := record.Host
	switch recordType {
	case "A":
		ips, err := net.LookupIP(domain)
		if err != nil {
			return records, err
		}
		for _, ip := range ips {
			records = append(records, ip.String())
		}
		return records, nil
	case "CNAME":
		name, err := net.LookupCNAME(domain)
		if err != nil {
			return records, err
		}
		records = append(records, name)
		return records, nil
	case "NS":
		ns, err := net.LookupNS(domain)
		if err != nil {
			return records, err
		}
		for _, n := range ns {
			records = append(records, n.Host)
		}
		return records, nil
	case "MX":
		mxs, err := net.LookupMX(domain)
		if err != nil {
			return records, err
		}
		for _, mx := range mxs {
			pref := string(mx.Pref)
			r := fmt.Sprintf("%s %s", mx.Host, pref)
			records = append(records, r)
		}
		return records, nil
	case "TXT":
		txts, err := net.LookupTXT(domain)
		if err != nil {
			return records, err
		}
		for _, txt := range txts {
			records = append(records, txt)
		}
		return records, nil
	default:
		return records, fmt.Errorf("Unknown record type %s", recordType)

	}
}

All'interno della funzione getRecord, viene effettuato un controllo sul tipo di record specificato. In base al tipo di record, vengono eseguite le seguenti azioni:

1. Per il tipo "A" (indirizzo IPv4), viene utilizzata la funzione net.LookupIP per cercare gli indirizzi IP associati al dominio.

2. Per il tipo "CNAME" (nome canonico), viene utilizzata la funzione net.LookupCNAME per cercare il nome canonico associato al dominio.

3. Per il tipo "NS" (server dei nomi), viene utilizzata la funzione net.LookupNS per cercare i server dei nomi associati al dominio.

4. Per il tipo "MX" (record di posta), viene utilizzata la funzione net.LookupMX per cercare i record MX associati al dominio.

5. Per il tipo "TXT" (record di testo), viene utilizzata la funzione net.LookupTXT per cercare i record TXT associati al dominio.

Ogni risultato ottenuto viene aggiunto all'array records, che alla fine viene restituito come risultato della funzione insieme a un eventuale errore.

Giungiamo infine alla funzione main:

func main() {
	record := DNSQuery{"gabrieleromanato.com", "A"}
	records, err := getRecord(record)
	if err != nil {
		fmt.Println(err)
	} else {
		for _, r := range records {
			fmt.Println(r)
		}
	}
}

La funzione main crea un oggetto DNSQuery con il dominio "gabrieleromanato.com" e il tipo di record "A". Poi chiama la funzione getRecord per ottenere i record DNS associati e gestisce eventuali errori. Se non ci sono errori, stampa i record DNS ottenuti uno per uno.