Esercizio - Client DNS con query e risposta costruite a mano (sul modello della prova pratica)

header (12 byte): ID | flag | QDCOUNT | ANCOUNT | NSCOUNT | ARCOUNT      (tutti i numeri in BIG ENDIAN)
domanda:          QNAME (etichette) | QTYPE (2) | QCLASS (2)
record:           NAME | TYPE (2) | CLASS (2) | TTL (4) | RDLENGTH (2) | RDATA (RDLENGTH byte)

/* dns_client.c - mini risolutore DNS (RFC 1035): costruisce a mano la query, la manda in UDP porta 53 e
 * decodifica la risposta (nomi compressi compresi). Riprova su TCP se il server segnala il troncamento (TC).
 *
 * Compilare:  gcc -Wall -Wextra -o dns_client dns_client.c
 * Autotest:   ./dns_client --test            (usa messaggi reali, senza rete)
 * Usare:      ./dns_client www.example.com            (record A)
 *             ./dns_client example.com MX 8.8.8.8      (tipo e server a scelta: A AAAA NS CNAME MX TXT)
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <stdint.h>
#include <errno.h>
#undef NDEBUG                      /* gli assert degli autotest devono restare attivi anche con -DNDEBUG */
#include <assert.h>
#include <time.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define T_A 1
#define T_NS 2
#define T_CNAME 5
#define T_MX 15
#define T_TXT 16
#define T_AAAA 28
#define MAX_MSG 4096

/* ---------- costruzione della query ---------- */

/* "www.example.com" -> 03 'w' 'w' 'w' 07 'e' 'x' 'a' 'm' 'p' 'l' 'e' 03 'c' 'o' 'm' 00
 * Ogni etichetta e' preceduta dalla sua lunghezza (max 63); il nome finisce con la lunghezza 0 (la radice). */
static int dns_encode_name(const char *name, uint8_t *out, size_t cap)
{
    size_t o = 0;
    while (*name) {
        const char *dot = strchr(name, '.');
        size_t l = dot ? (size_t)(dot - name) : strlen(name);
        if (l == 0 || l > 63 || o + l + 2 > cap)
            return -1;                             /* etichetta vuota o troppo lunga */
        out[o++] = (uint8_t)l;
        memcpy(out + o, name, l);
        o += l;
        name += l;
        if (*name == '.')
            name++;
    }
    out[o++] = 0;
    return (int)o;
}

/* Header (12 byte) + una domanda: QNAME, QTYPE (2 byte), QCLASS (2 byte, 1 = IN). Tutto in big endian. */
static int dns_build_query(uint8_t *buf, size_t cap, uint16_t id, const char *name, uint16_t qtype)
{
    if (cap < 12)
        return -1;
    memset(buf, 0, 12);
    buf[0] = (uint8_t)(id >> 8);
    buf[1] = (uint8_t)id;
    buf[2] = 0x01;                                 /* flags = 0x0100: QR=0 (query), opcode 0, RD=1 (ricorsione desiderata) */
    buf[5] = 1;                                    /* QDCOUNT = 1; ANCOUNT, NSCOUNT, ARCOUNT = 0 */
    int n = dns_encode_name(name, buf + 12, cap - 12 - 4);
    if (n < 0)
        return -1;
    size_t o = 12 + (size_t)n;
    buf[o++] = (uint8_t)(qtype >> 8);
    buf[o++] = (uint8_t)qtype;
    buf[o++] = 0;
    buf[o++] = 1;                                  /* QCLASS = IN */
    return (int)o;
}

/* ---------- lettura della risposta ---------- */

static unsigned rd16(const uint8_t *p) { return (unsigned)p[0] << 8 | p[1]; }
static uint32_t rd32(const uint8_t *p) { return (uint32_t)p[0] << 24 | (uint32_t)p[1] << 16 | (uint32_t)p[2] << 8 | p[3]; }

/* Legge un nome a partire da m[*pos]. Un byte che inizia con i bit 11 e' un PUNTATORE di compressione:
 * i 14 bit (6 + 8) sono l'offset, dall'inizio del messaggio, dove continua il nome.
 * *pos avanza fino a dopo il nome nella posizione ORIGINALE (dopo il puntatore, se c'e'). Torna 0 o -1. */
static int dns_read_name(const uint8_t *m, size_t len, size_t *pos, char *out, size_t outsz)
{
    size_t p = *pos, o = 0;
    int jumped = 0, hops = 0;
    for (;;) {
        if (p >= len)
            return -1;
        uint8_t l = m[p];
        if (l == 0) {
            p++;
            break;
        }
        if ((l & 0xC0) == 0xC0) {
            if (p + 1 >= len)
                return -1;
            size_t off = (size_t)(l & 0x3F) << 8 | m[p + 1];
            if (!jumped)
                *pos = p + 2;                      /* la lettura "normale" riprende dopo il puntatore */
            jumped = 1;
            if (off >= len || ++hops > 16)
                return -1;                         /* puntatore fuori dal messaggio o ciclo infinito */
            p = off;
            continue;
        }
        if (l & 0xC0)
            return -1;                             /* 01 e 10 sono riservati */
        p++;
        if (p + l > len || o + l + 2 > outsz)
            return -1;
        if (o > 0)
            out[o++] = '.';
        memcpy(out + o, m + p, l);
        o += l;
        p += l;
    }
    out[o] = '\0';
    if (o == 0)
        snprintf(out, outsz, ".");                 /* il nome vuoto e' la radice */
    if (!jumped)
        *pos = p;
    return 0;
}

/* Decodifica la sezione risposte. Scrive una riga per record in lines[]. Torna il numero di record
 * (o -1 se il messaggio e' malformato); *rcode = codice di risposta (0 = nessun errore, 3 = NXDOMAIN). */
static int dns_parse(const uint8_t *m, size_t len, char lines[][200], int maxlines, int *rcode)
{
    if (len < 12)
        return -1;
    *rcode = m[3] & 0x0F;
    unsigned qd = rd16(m + 4), an = rd16(m + 6);
    size_t pos = 12;
    char name[256];
    for (unsigned i = 0; i < qd; i++) {            /* le domande si saltano: nome + 4 byte */
        if (dns_read_name(m, len, &pos, name, sizeof name) < 0 || pos + 4 > len)
            return -1;
        pos += 4;
    }
    int n = 0;
    for (unsigned i = 0; i < an; i++) {
        if (dns_read_name(m, len, &pos, name, sizeof name) < 0 || pos + 10 > len)
            return -1;
        unsigned type = rd16(m + pos);
        uint32_t ttl = rd32(m + pos + 4);
        unsigned rdlen = rd16(m + pos + 8);
        pos += 10;
        if (pos + rdlen > len)
            return -1;
        if (n >= maxlines) {
            pos += rdlen;
            continue;
        }
        char *ln = lines[n];
        int k = snprintf(ln, 200, "%s\t%u\tIN\t", name, (unsigned)ttl);
        size_t rp = pos;                           /* posizione di lavoro dentro RDATA */
        char target[256];
        if (type == T_A && rdlen == 4) {
            snprintf(ln + k, (size_t)(200 - k), "A\t%d.%d.%d.%d", m[pos], m[pos + 1], m[pos + 2], m[pos + 3]);
        } else if (type == T_AAAA && rdlen == 16) {
            char ip[INET6_ADDRSTRLEN];
            inet_ntop(AF_INET6, m + pos, ip, sizeof ip);
            snprintf(ln + k, (size_t)(200 - k), "AAAA\t%s", ip);
        } else if ((type == T_CNAME || type == T_NS) && dns_read_name(m, len, &rp, target, sizeof target) == 0) {
            snprintf(ln + k, (size_t)(200 - k), "%s\t%s", type == T_CNAME ? "CNAME" : "NS", target);
        } else if (type == T_MX && rdlen >= 3) {
            unsigned pref = rd16(m + pos);
            rp = pos + 2;
            if (dns_read_name(m, len, &rp, target, sizeof target) < 0)
                return -1;
            snprintf(ln + k, (size_t)(200 - k), "MX\t%u %s", pref, target);
        } else if (type == T_TXT) {
            size_t o = 0;
            k += snprintf(ln + k, (size_t)(200 - k), "TXT\t");
            while (o < rdlen && k < 190) {         /* TXT = una o piu' stringhe, ognuna con un byte di lunghezza */
                unsigned l = m[pos + o++];
                if (o + l > rdlen)
                    return -1;
                k += snprintf(ln + k, (size_t)(200 - k), "\"%.*s\" ", (int)l, (const char *)m + pos + o);
                o += l;
            }
        } else {
            snprintf(ln + k, (size_t)(200 - k), "tipo %u (%u byte)", type, rdlen);
        }
        n++;
        pos += rdlen;
    }
    return n;
}

/* ---------- rete ---------- */

/* UDP: un datagramma di domanda, un datagramma di risposta. Torna la lunghezza della risposta o -1. */
static int query_udp(const char *server, const uint8_t *q, size_t qlen, uint8_t *resp, size_t cap)
{
    int fd = socket(AF_INET, SOCK_DGRAM, 0);
    if (fd < 0)
        return -1;
    struct timeval tv = {.tv_sec = 3, .tv_usec = 0};
    setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof tv);
    struct sockaddr_in sa;
    memset(&sa, 0, sizeof sa);
    sa.sin_family = AF_INET;
    sa.sin_port = htons(53);
    if (inet_pton(AF_INET, server, &sa.sin_addr) != 1) {
        close(fd);
        return -1;
    }
    ssize_t n = -1;
    if (sendto(fd, q, qlen, 0, (struct sockaddr *)&sa, sizeof sa) == (ssize_t)qlen)
        n = recvfrom(fd, resp, cap, 0, NULL, NULL);
    close(fd);
    return (int)n;
}

/* TCP (RFC 1035 par. 4.2.2): ogni messaggio e' preceduto da 2 byte con la sua lunghezza. */
static int query_tcp(const char *server, const uint8_t *q, size_t qlen, uint8_t *resp, size_t cap)
{
    int fd = socket(AF_INET, SOCK_STREAM, 0);
    if (fd < 0)
        return -1;
    struct sockaddr_in sa;
    memset(&sa, 0, sizeof sa);
    sa.sin_family = AF_INET;
    sa.sin_port = htons(53);
    if (inet_pton(AF_INET, server, &sa.sin_addr) != 1 || connect(fd, (struct sockaddr *)&sa, sizeof sa) < 0) {
        close(fd);
        return -1;
    }
    uint8_t pre[2] = {(uint8_t)(qlen >> 8), (uint8_t)qlen};
    uint8_t msg[MAX_MSG];
    memcpy(msg, pre, 2);
    memcpy(msg + 2, q, qlen);
    if (write(fd, msg, qlen + 2) != (ssize_t)(qlen + 2)) {
        close(fd);
        return -1;
    }
    uint8_t lb[2];
    size_t got = 0;
    ssize_t r;
    while (got < 2 && (r = read(fd, lb + got, 2 - got)) > 0)
        got += (size_t)r;
    size_t rl = got == 2 ? rd16(lb) : 0;
    if (rl == 0 || rl > cap) {
        close(fd);
        return -1;
    }
    got = 0;
    while (got < rl && (r = read(fd, resp + got, rl - got)) > 0)
        got += (size_t)r;
    close(fd);
    return got == rl ? (int)rl : -1;
}

/* Primo "nameserver" di /etc/resolv.conf (solo IPv4), altrimenti 8.8.8.8. */
static void default_server(char *out, size_t size)
{
    snprintf(out, size, "8.8.8.8");
    FILE *f = fopen("/etc/resolv.conf", "r");
    if (f == NULL)
        return;
    char line[256], ip[64];
    while (fgets(line, sizeof line, f))
        if (sscanf(line, "nameserver %63s", ip) == 1) {
            struct in_addr a;
            if (inet_pton(AF_INET, ip, &a) == 1) {
                snprintf(out, size, "%s", ip);
                break;
            }
        }
    fclose(f);
}

static int selftest(void)
{
    /* messaggi reali: query e risposta per www.example.com tipo A (id 0x1234) */
    static const uint8_t query[] = {0x12, 0x34, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 'w', 'w', 'w', 0x07,
                                    'e', 'x', 'a', 'm', 'p', 'l', 'e', 0x03, 'c', 'o', 'm', 0x00, 0x00, 0x01, 0x00, 0x01};
    uint8_t buf[512];
    int n = dns_build_query(buf, sizeof buf, 0x1234, "www.example.com", T_A);
    assert(n == (int)sizeof query && memcmp(buf, query, sizeof query) == 0);
    assert(dns_encode_name("a..b", buf, sizeof buf) == -1);

    static const uint8_t resp[] = {
        0x12, 0x34, 0x81, 0x80, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,                /* header: QR=1 RD=1 RA=1, 1 domanda, 2 risposte */
        0x03, 'w', 'w', 'w', 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e', 0x03, 'c', 'o', 'm', 0x00, 0x00, 0x01, 0x00, 0x01,
        0xc0, 0x0c, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x01, 0x17, 0x00, 0x04, 0x68, 0x14, 0x17, 0x9a,   /* nome = puntatore a offset 12 */
        0xc0, 0x0c, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x01, 0x17, 0x00, 0x04, 0xac, 0x42, 0x93, 0xf3};
    char lines[8][200];
    int rcode;
    int cnt = dns_parse(resp, sizeof resp, lines, 8, &rcode);
    assert(cnt == 2 && rcode == 0);
    assert(strcmp(lines[0], "www.example.com\t279\tIN\tA\t104.20.23.154") == 0);
    assert(strcmp(lines[1], "www.example.com\t279\tIN\tA\t172.66.147.243") == 0);

    /* MX con "." (null MX, RFC 7505): preferenza 0, nome vuoto */
    static const uint8_t mx[] = {
        0x12, 0x34, 0x81, 0x80, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
        0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e', 0x03, 'c', 'o', 'm', 0x00, 0x00, 0x0f, 0x00, 0x01,
        0xc0, 0x0c, 0x00, 0x0f, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05, 0x00, 0x03, 0x00, 0x00, 0x00};
    cnt = dns_parse(mx, sizeof mx, lines, 8, &rcode);
    assert(cnt == 1 && strcmp(lines[0], "example.com\t5\tIN\tMX\t0 .") == 0);

    /* messaggi malformati: puntatore ciclico, troncamento */
    static const uint8_t loop[] = {0, 1, 0x81, 0x80, 0, 1, 0, 0, 0, 0, 0, 0, 0xc0, 0x0c, 0, 1, 0, 1};
    assert(dns_parse(loop, sizeof loop, lines, 8, &rcode) == -1);
    assert(dns_parse(resp, 40, lines, 8, &rcode) == -1);
    puts("dns_client: autotest superato");
    return 0;
}

int main(int argc, char **argv)
{
    if (argc == 2 && strcmp(argv[1], "--test") == 0)
        return selftest();
    if (argc < 2 || argc > 4) {
        fprintf(stderr, "uso: %s nome [A|AAAA|NS|CNAME|MX|TXT] [server_dns]\n", argv[0]);
        return 1;
    }
    static const struct { const char *name; uint16_t code; } types[] = {
        {"A", T_A}, {"AAAA", T_AAAA}, {"NS", T_NS}, {"CNAME", T_CNAME}, {"MX", T_MX}, {"TXT", T_TXT}};
    uint16_t qtype = T_A;
    if (argc >= 3) {
        qtype = 0;
        for (size_t i = 0; i < sizeof types / sizeof types[0]; i++)
            if (strcasecmp(argv[2], types[i].name) == 0)
                qtype = types[i].code;
        if (qtype == 0) {
            fprintf(stderr, "tipo non supportato: %s\n", argv[2]);
            return 1;
        }
    }
    char server[64];
    if (argc == 4)
        snprintf(server, sizeof server, "%s", argv[3]);
    else
        default_server(server, sizeof server);

    srand((unsigned)time(NULL) ^ (unsigned)getpid());
    uint16_t id = (uint16_t)rand();                /* l'ID abbina risposta e domanda (meglio se imprevedibile) */
    uint8_t q[512], resp[MAX_MSG];
    int qlen = dns_build_query(q, sizeof q, id, argv[1], qtype);
    if (qlen < 0) {
        fprintf(stderr, "nome non valido\n");
        return 1;
    }
    int rlen = query_udp(server, q, (size_t)qlen, resp, sizeof resp);
    if (rlen >= 12 && (resp[2] & 0x02)) {          /* bit TC: risposta troncata, si ripete su TCP */
        fprintf(stderr, "risposta troncata (TC), riprovo con TCP\n");
        rlen = query_tcp(server, q, (size_t)qlen, resp, sizeof resp);
    }
    if (rlen < 12) {
        fprintf(stderr, "nessuna risposta da %s\n", server);
        return 1;
    }
    if (rd16(resp) != id || !(resp[2] & 0x80)) {   /* ID diverso o QR=0: non e' la risposta alla nostra domanda */
        fprintf(stderr, "risposta non valida (ID o flag QR)\n");
        return 1;
    }
    char lines[32][200];
    int rcode;
    int n = dns_parse(resp, (size_t)rlen, lines, 32, &rcode);
    if (n < 0) {
        fprintf(stderr, "messaggio DNS malformato\n");
        return 1;
    }
    static const char *rc_names[] = {"NOERROR", "FORMERR", "SERVFAIL", "NXDOMAIN", "NOTIMP", "REFUSED"};
    printf(";; server %s, rcode %s, %d risposte\n", server, rcode < 6 ? rc_names[rcode] : "?", n);
    for (int i = 0; i < n; i++)
        printf("%s\n", lines[i]);
    return rcode == 0 ? 0 : 2;
}

$ gcc -Wall -Wextra -o dns_client dns_client.c
$ ./dns_client --test
dns_client: autotest superato

$ ./dns_client www.example.com
;; server 192.168.1.1, rcode NOERROR, 2 risposte
www.example.com	279	IN	A	104.20.23.154
www.example.com	279	IN	A	172.66.147.243

$ ./dns_client example.com MX 8.8.8.8
;; server 8.8.8.8, rcode NOERROR, 1 risposte
example.com	5	IN	MX	0 .

$ ./dns_client example.com TXT
;; server 192.168.1.1, rcode NOERROR, 2 risposte
example.com	300	IN	TXT	"v=spf1 -all"
...

$ ./dns_client nonesiste.example.invalid
;; server 192.168.1.1, rcode NXDOMAIN, 0 risposte

12 34                   ID
01 00                   flag: QR=0 (domanda), Opcode=0, RD=1
00 01  00 00 00 00 00 00  QDCOUNT=1, ANCOUNT=0, NSCOUNT=0, ARCOUNT=0
03 77 77 77             3 'w' 'w' 'w'
07 65 78 61 6d 70 6c 65 7 'e' 'x' 'a' 'm' 'p' 'l' 'e'
03 63 6f 6d             3 'c' 'o' 'm'
00                      fine del nome
00 01                   QTYPE  = A
00 01                   QCLASS = IN