10 files changed, 1468 insertions, 0 deletions

diff --git a/src/packet/buffer.c b/src/packet/buffer.c
new file mode 100644
index 0000000..2d9386d
--- /dev/null
+++ b/src/packet/buffer.c
@@ -0,0 +1,247 @@
+#include "buffer.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct PacketBuffer {
+    uint8_t* arr;
+    int capacity;
+    int index;
+    int size;
+};
+
+PacketBuffer* buffer_create(int capacity) {
+    PacketBuffer* buffer = malloc(sizeof(PacketBuffer));
+    buffer->arr = malloc(capacity);
+    memset(buffer->arr, 0, capacity);
+    buffer->capacity = capacity;
+    buffer->size = 0;
+    buffer->index = 0;
+    return buffer;
+}
+
+void buffer_free(PacketBuffer* buffer) {
+    free(buffer->arr);
+    free(buffer);
+}
+
+void buffer_seek(PacketBuffer* buffer, int index) {
+    buffer->index = index;
+}
+
+uint8_t buffer_read(PacketBuffer* buffer) {
+    if (buffer->index >= buffer->size) {
+        return 0;
+    }
+    uint8_t data = buffer->arr[buffer->index];
+    buffer->index++;
+    return data;
+}
+
+uint16_t buffer_read_short(PacketBuffer* buffer) {
+    return
+        (uint16_t) buffer_read(buffer) << 8 |
+        (uint16_t) buffer_read(buffer);
+}
+
+uint32_t buffer_read_int(PacketBuffer* buffer) {
+    return
+        (uint32_t) buffer_read(buffer) << 24 |
+        (uint32_t) buffer_read(buffer) << 16 |
+        (uint32_t) buffer_read(buffer) << 8 |
+        (uint32_t) buffer_read(buffer);
+}
+
+uint8_t buffer_get(PacketBuffer* buffer, int index) {
+    if (index >= buffer->size) {
+        return 0;
+    }
+    uint8_t data = buffer->arr[index];
+    return data;
+}
+
+uint8_t* buffer_get_range(PacketBuffer* buffer, int start, int len) {
+    uint8_t* arr = malloc(len);
+    for (int i = 0; i < len; i++) {
+        arr[i] = buffer_get(buffer, start + i);
+    }
+    return arr;
+}
+
+uint16_t buffer_get_size(PacketBuffer* buffer) {
+    return (uint16_t) buffer->size + 1;
+}
+
+static void write(uint8_t** buffer, uint8_t* size, uint8_t* capacity, uint8_t data) {
+    if (*size >= *capacity) {
+        if (*capacity >= 128) {
+            *capacity = 255;
+        } else {
+            *capacity *= 2;
+        }
+        *buffer = realloc(*buffer, *capacity); 
+    }
+    (*buffer)[*size] = data;
+    (*size)++; 
+}
+
+void buffer_read_qname(PacketBuffer* buffer, uint8_t** out) {
+    int index = buffer->index;
+    int jumped = 0;
+
+    int max_jumps = 5;
+    int jumps_performed = 0;
+
+    uint8_t length = 0;
+    uint8_t capacity = 8;
+    *out = malloc(capacity);
+    write(out, &length, &capacity, 0);
+
+    while(1) {
+        if (jumps_performed > max_jumps) {
+            break;
+        }
+
+        uint8_t len = buffer_get(buffer, index);
+
+        if ((len & 0xC0) == 0xC0) {
+            if (jumped == 0) {
+                buffer_seek(buffer, index + 2);
+            } 
+
+            uint16_t b2 = (uint16_t) buffer_get(buffer, index + 1);
+            uint16_t offset = ((((uint16_t) len) ^ 0xC0) << 8) | b2;
+            index = (int) offset;
+            jumped = 1;
+            jumps_performed++;
+            continue;         
+        }
+
+        index++;
+
+        if (len == 0) {
+            break;
+        }
+
+        if (length > 1) {
+            write(out, &length, &capacity, '.');
+        }
+
+        uint8_t* range = buffer_get_range(buffer, index, len);
+        for (uint8_t i = 0; i < len; i++) {
+            write(out, &length, &capacity, range[i]);
+        } 
+        free(range);
+
+        index += (int) len;
+    }
+
+    if (jumped == 0) {
+        buffer_seek(buffer, index);
+    }
+    
+    (*out)[0] = length - 1;
+}
+
+void buffer_read_string(PacketBuffer* buffer, uint8_t** out) {
+    uint8_t len = buffer_read(buffer);
+    buffer_read_n(buffer, out, len);
+}
+
+static void buffer_expand(PacketBuffer* buffer, int capacity) {
+    if (buffer->capacity >= capacity) return;
+
+    buffer->arr = realloc(buffer->arr, capacity);
+    memset(buffer->arr + buffer->capacity, 0, capacity - buffer->capacity);
+    buffer->capacity = capacity;
+}
+
+void buffer_read_n(PacketBuffer* buffer, uint8_t** out, uint8_t len) {
+    buffer_expand(buffer, buffer->index + len + 1);
+    *out = malloc(len + 1);
+    *out[0] = len;
+    memcpy(*out + 1, buffer->arr + buffer->index, len);
+    buffer->index += len;
+}
+
+void buffer_write(PacketBuffer* buffer, uint8_t data) {
+    buffer_expand(buffer, buffer->index);
+    if (buffer->size < buffer->index + 1) {
+        buffer->size = buffer->index + 1;
+    }
+    buffer->arr[buffer->index] = data;
+    buffer->index++;
+}
+
+void buffer_write_short(PacketBuffer* buffer, uint16_t data) {
+    buffer_write(buffer, (uint8_t)(data >> 8));
+    buffer_write(buffer, (uint8_t)(data & 0xFF));
+}
+
+void buffer_write_int(PacketBuffer* buffer, uint32_t data) {
+    buffer_write(buffer, (uint8_t)(data >> 24));
+    buffer_write(buffer, (uint8_t)(data >> 16));
+    buffer_write(buffer, (uint8_t)(data >> 8));
+    buffer_write(buffer, (uint8_t)(data & 0xFF));
+}
+
+void buffer_write_qname(PacketBuffer* buffer, uint8_t* in) {
+    uint8_t part = 0;
+    uint8_t len = in[0];
+    
+    buffer_write(buffer, 0);
+    
+    if (len == 0) {
+        return;
+    }    
+
+    for(uint8_t i = 0; i < len; i ++) {
+        if (in[i+1] == '.') {
+            buffer_set(buffer, part, buffer->index - (int)part - 1);
+            buffer_write(buffer, 0);
+            part = 0;
+        } else {
+            buffer_write(buffer, in[i+1]);
+            part++;
+        }
+    }
+    buffer_set(buffer, part, buffer->index - (int)part - 1);
+    buffer_write(buffer, 0);
+}
+
+void buffer_write_string(PacketBuffer* buffer, uint8_t* in) {
+    buffer_write(buffer, in[0]);
+    buffer_write_n(buffer, in + 1, in[0]);
+}
+
+void buffer_write_n(PacketBuffer* buffer, uint8_t* in, int len) {
+    buffer_expand(buffer, buffer->size + len);
+    memcpy(buffer->arr + buffer->index, in, len);
+    buffer->size += len;
+    buffer->index += len;
+}
+
+void buffer_set(PacketBuffer* buffer, uint8_t data, int index) {
+    if (index > buffer->size) {
+        return;
+    }
+    buffer->arr[index] = data;
+}
+
+void buffer_set_uint16_t(PacketBuffer* buffer, uint16_t data, int index) {
+    buffer_set(buffer, (uint8_t)(data >> 8), index);
+    buffer_set(buffer, (uint8_t)(data & 0xFF), index + 1);
+}
+
+int buffer_get_index(PacketBuffer* buffer) {
+    return buffer->index;
+}
+
+void buffer_step(PacketBuffer* buffer, int len) {
+    buffer->index += len;
+}
+
+uint8_t* buffer_get_ptr(PacketBuffer* buffer) {
+    return buffer->arr;
+}
diff --git a/src/packet/buffer.h b/src/packet/buffer.h
new file mode 100644
index 0000000..ad3145d
--- /dev/null
+++ b/src/packet/buffer.h
@@ -0,0 +1,51 @@
+#pragma once
+
+#include <stdint.h>
+
+typedef struct PacketBuffer PacketBuffer;
+
+PacketBuffer* buffer_create(int capacity);
+
+void buffer_free(PacketBuffer* buffer);
+
+void buffer_seek(PacketBuffer* buffer, int index);
+
+uint8_t buffer_read(PacketBuffer* buffer);
+
+uint16_t buffer_read_short(PacketBuffer* buffer);
+
+uint32_t buffer_read_int(PacketBuffer* buffer);
+
+uint8_t buffer_get(PacketBuffer* buffer, int index);
+
+uint8_t* buffer_get_range(PacketBuffer* buffer, int start, int len);
+
+uint16_t buffer_get_size(PacketBuffer* buffer);
+
+void buffer_read_qname(PacketBuffer* buffer, uint8_t** out);
+
+void buffer_read_string(PacketBuffer* buffer, uint8_t** out);
+
+void buffer_read_n(PacketBuffer* buffer, uint8_t** out, uint8_t len);
+
+void buffer_write(PacketBuffer* buffer, uint8_t data);
+
+void buffer_write_short(PacketBuffer* buffer, uint16_t data);
+
+void buffer_write_int(PacketBuffer* buffer, uint32_t data);
+
+void buffer_write_qname(PacketBuffer* buffer, uint8_t* in);
+
+void buffer_write_string(PacketBuffer* buffer, uint8_t* in);
+
+void buffer_write_n(PacketBuffer* buffer, uint8_t* in, int len);
+
+void buffer_set(PacketBuffer* buffer, uint8_t data, int index);
+
+void buffer_set_uint16_t(PacketBuffer* buffer, uint16_t data, int index);
+
+int buffer_get_index(PacketBuffer* buffer);
+
+void buffer_step(PacketBuffer* buffer, int len);
+
+uint8_t* buffer_get_ptr(PacketBuffer* buffer);
diff --git a/src/packet/header.c b/src/packet/header.c
new file mode 100644
index 0000000..b74ebb1
--- /dev/null
+++ b/src/packet/header.c
@@ -0,0 +1,108 @@
+#include "header.h"
+#include "buffer.h"
+
+#include <netinet/in.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <arpa/inet.h>
+
+uint8_t rescode_to_id(ResultCode code) {
+    switch(code) {
+        case NOERROR:
+            return 0;
+        case FORMERR:
+            return 1;
+        case SERVFAIL:
+            return 2;
+        case NXDOMAIN:
+            return 3;
+        case NOTIMP:
+            return 4;
+        case REFUSED:
+            return 5;
+        default:
+            return 2;
+    }
+}
+
+ResultCode rescode_from_id(uint8_t id) {
+    switch(id) {
+        case 0:
+            return NOERROR;
+        case 1:
+            return FORMERR;
+        case 2:
+            return SERVFAIL;
+        case 3:
+            return NXDOMAIN;
+        case 4:
+            return NOTIMP;
+        case 5:
+            return REFUSED;
+        default:
+            return FORMERR;
+    }
+}
+
+const char* str_from_code(ResultCode code) {
+    switch(code) {
+        case NOERROR: return "NOERROR";
+        case FORMERR: return "FORMERR";
+        case SERVFAIL: return "SERVFAIL";
+        case NXDOMAIN: return "NXDOMAIN";
+        case NOTIMP: return "NOTIMP";
+        case REFUSED: return "REFUSED";
+        default: return "????";
+    }
+}
+
+#define MAX(var, max) var = var > max ? max : var;
+
+void read_header(PacketBuffer* buffer, Header* header) {
+    // memset(header, 0, sizeof(Header));
+    header->id = buffer_read_short(buffer);
+
+    uint8_t a = buffer_read(buffer);
+    header->recursion_desired = (a & (1 << 0)) > 0;
+    header->truncated_message = (a & (1 << 1)) > 0;
+    header->authorative_answer = (a & (1 << 2)) > 0;
+    header->opcode = (a >> 3) & 0x0F;
+    header->response = (a & (1 << 7)) > 0;
+
+    uint8_t b = buffer_read(buffer);
+    header->rescode = rescode_from_id(b & 0x0F);
+    header->checking_disabled = (b & (1 << 4)) > 0;
+    header->authed_data = (b& (1 << 4)) > 0;
+    header->z = (b & (1 << 6)) > 0;
+    header->recursion_available = (b & (1 << 7)) > 0;
+    header->questions = buffer_read_short(buffer);
+    header->answers = buffer_read_short(buffer);
+    header->authoritative_entries = buffer_read_short(buffer);
+    header->resource_entries = buffer_read_short(buffer);
+}
+
+void write_header(PacketBuffer* buffer, Header* header) {
+    buffer_write_short(buffer, header->id);
+
+    buffer_write(buffer,
+        ((uint8_t) header->recursion_desired) |
+        ((uint8_t) header->truncated_message << 1) |
+        ((uint8_t) header->authorative_answer << 2) |
+        (header->opcode << 3) |
+        ((uint8_t) header->response << 7) 
+    );
+
+    buffer_write(buffer, 
+        (rescode_to_id(header->rescode)) |
+        ((uint8_t) header->checking_disabled << 4) |
+        ((uint8_t) header->authed_data << 5) |
+        ((uint8_t) header->z << 6) |
+        ((uint8_t) header->recursion_available << 7) 
+    );
+
+    buffer_write_short(buffer, header->questions);
+    buffer_write_short(buffer, header->answers);
+    buffer_write_short(buffer, header->authoritative_entries);
+    buffer_write_short(buffer, header->resource_entries);
+}
diff --git a/src/packet/header.h b/src/packet/header.h
new file mode 100644
index 0000000..a824ec3
--- /dev/null
+++ b/src/packet/header.h
@@ -0,0 +1,42 @@
+#pragma once
+
+#include "buffer.h"
+
+#include <stdbool.h>
+
+typedef enum {
+    NOERROR,    // 0
+    FORMERR,    // 1
+    SERVFAIL,   // 2
+    NXDOMAIN,   // 3,
+    NOTIMP,     // 4
+    REFUSED,    // 5
+} ResultCode;
+
+uint8_t rescode_to_id(ResultCode code);
+ResultCode rescode_from_id(uint8_t id);
+
+typedef struct {
+    uint16_t id;
+
+    bool recursion_desired;     // 1 bit
+    bool truncated_message;     // 1 bit
+    bool authorative_answer;    // 1 bit
+    uint8_t opcode;               // 4 bits
+    bool response;              // 1 bit
+
+    ResultCode rescode;         // 4 bits
+    bool checking_disabled;     // 1 bit
+    bool authed_data;           // 1 bit
+    bool z;                     // 1 bit
+    bool recursion_available;   // 1 bit
+
+    uint16_t questions;               // 16 bits
+    uint16_t answers;                 // 16 bits
+    uint16_t authoritative_entries;   // 16 bits
+    uint16_t resource_entries;        // 16 bits
+} Header;
+
+void read_header(PacketBuffer* buffer, Header* header);
+void write_header(PacketBuffer* buffer, Header* header);
+const char* str_from_code(ResultCode code);
diff --git a/src/packet/packet.c b/src/packet/packet.c
new file mode 100644
index 0000000..83dc5c3
--- /dev/null
+++ b/src/packet/packet.c
@@ -0,0 +1,184 @@
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "packet.h"
+#include "buffer.h"
+#include "header.h"
+#include "question.h"
+#include "record.h"
+
+void read_packet(PacketBuffer* buffer, Packet* packet) {
+    read_header(buffer, &packet->header);
+    
+    packet->questions = malloc(sizeof(Question) * packet->header.questions);
+    for(uint16_t i = 0; i < packet->header.questions; i++) {
+        if (!read_question(buffer, &packet->questions[i])) {
+            i--;
+            packet->header.questions--;
+        }
+    }
+
+    packet->answers = malloc(sizeof(Record) * packet->header.answers);
+    for(uint16_t i = 0; i < packet->header.answers; i++) {
+        if (!read_record(buffer, &packet->answers[i])) {
+            i--;
+            packet->header.answers--;
+        }
+    }
+
+    packet->authorities = malloc(sizeof(Record) * packet->header.authoritative_entries);
+    for(uint16_t i = 0; i < packet->header.authoritative_entries; i++) {
+        if (!read_record(buffer, &packet->authorities[i])) {
+            i--;
+            packet->header.authoritative_entries--;
+        }
+    }
+
+    packet->resources = malloc(sizeof(Record) * packet->header.resource_entries);
+    for(uint16_t i = 0; i < packet->header.resource_entries; i++) {
+        if (!read_record(buffer, &packet->resources[i])) {
+            i--;
+            packet->header.resource_entries--;
+        }
+    }
+}
+
+void write_packet(PacketBuffer* buffer, Packet* packet) {
+    write_header(buffer, &packet->header);
+    
+    for(uint16_t i = 0; i < packet->header.questions; i++) {
+        write_question(buffer, &packet->questions[i]);
+    }
+
+    for(uint16_t i = 0; i < packet->header.answers; i++) {
+        write_record(buffer, &packet->answers[i]);
+    }
+
+    for(uint16_t i = 0; i < packet->header.authoritative_entries; i++) {
+        write_record(buffer, &packet->authorities[i]);
+    }
+
+    for(uint16_t i = 0; i < packet->header.resource_entries; i++) {
+        write_record(buffer, &packet->resources[i]);
+    }
+}
+
+void free_packet(Packet* packet) {
+    
+    for(uint16_t i = 0; i < packet->header.questions; i++) {
+        free_question(&packet->questions[i]);
+    }
+    free(packet->questions);
+
+    for(uint16_t i = 0; i < packet->header.answers; i++) {
+        free_record(&packet->answers[i]);
+    }
+    free(packet->answers);
+
+    for(uint16_t i = 0; i < packet->header.authoritative_entries; i++) {
+        free_record(&packet->authorities[i]);
+    }
+    free(packet->authorities);
+
+    for(uint16_t i = 0; i < packet->header.resource_entries; i++) {
+        free_record(&packet->resources[i]);
+    }
+    free(packet->resources);
+}
+
+bool get_random_a(Packet* packet, IpAddr* addr) {
+    for (uint16_t i = 0; i < packet->header.answers; i++) {
+        Record record = packet->answers[i];
+        if (record.type == A) {
+            create_ip_addr(record.data.a.addr, addr);
+            return true;
+        } else if (record.type == AAAA) {
+            create_ip_addr6(record.data.aaaa.addr, addr);
+            return true;
+        }
+    }
+    return false;
+}
+
+static bool ends_with(uint8_t* full, uint8_t* end) {
+    uint8_t check = end[0];
+    uint8_t len = full[0];
+
+    if (check > len) {
+        return false;
+    }
+
+    for(uint8_t i = 0; i < check; i++) {
+        if (end[check - 1 - i] != full[len - 1 - i]) {
+            return false;
+        }
+    }
+    
+    return true;
+}
+
+static bool equals(uint8_t* a, uint8_t* b) {
+    if (a[0] != b[0]) {
+        return false;
+    }
+
+    for(uint8_t i = 1; i < a[0] + 1; i++) {
+        if(a[i] != b[i]) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool get_resolved_ns(Packet* packet, uint8_t* qname, IpAddr* addr) {
+    for (uint16_t i = 0; i < packet->header.authoritative_entries; i++) {
+        Record record = packet->authorities[i];
+        if (record.type != NS) {
+            continue;
+        }
+
+        if(!ends_with(qname, record.domain)) {
+            continue;
+        }
+
+        for (uint16_t i = 0; i < packet->header.resource_entries; i++) {
+            Record resource = packet->resources[i];
+            if (!equals(record.data.ns.host, resource.domain)) {
+                continue;
+            }
+
+            if (resource.type == A) {
+                create_ip_addr(record.data.a.addr, addr);
+                return true;
+            } else if (resource.type == AAAA) {
+                create_ip_addr6(record.data.aaaa.addr, addr);
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+bool get_unresoled_ns(Packet* packet, uint8_t* qname, Question* question) {
+    for (uint16_t i = 0; i < packet->header.authoritative_entries; i++) {
+        Record record = packet->authorities[i];
+        if (record.type != NS) {
+            continue;
+        }
+
+        if(!ends_with(qname, record.domain)) {
+            continue;
+        }
+
+        uint8_t* host = record.data.ns.host;
+
+        question->qtype = NS;
+        question->domain = malloc(host[0] + 1);
+        memcpy(question->domain, host, host[0] + 1);
+        return true;
+    }
+    return false;
+}
diff --git a/src/packet/packet.h b/src/packet/packet.h
new file mode 100644
index 0000000..12845b9
--- /dev/null
+++ b/src/packet/packet.h
@@ -0,0 +1,25 @@
+#pragma once
+
+#include "buffer.h"
+#include "question.h"
+#include "header.h"
+#include "record.h"
+#include "../client/addr.h"
+
+#include <stdbool.h>
+
+typedef struct {
+    Header header;
+    Question* questions;
+    Record* answers;
+    Record* authorities;
+    Record* resources;
+} Packet;
+
+void read_packet(PacketBuffer* buffer, Packet* packet);
+void write_packet(PacketBuffer* buffer, Packet* packet);
+void free_packet(Packet* packet);
+
+bool get_random_a(Packet* packet, IpAddr* addr);
+bool get_resolved_ns(Packet* packet, uint8_t* qname, IpAddr* addr);
+bool get_unresoled_ns(Packet* packet, uint8_t* qname, Question* question);
diff --git a/src/packet/question.c b/src/packet/question.c
new file mode 100644
index 0000000..8159a07
--- /dev/null
+++ b/src/packet/question.c
@@ -0,0 +1,79 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+
+#include "question.h"
+#include "buffer.h"
+#include "record.h"
+
+void create_question(const char* domain, RecordType qtype, Question* question) {
+    uint8_t len = strlen(domain);
+    question->domain = malloc(len + 1);
+    question->qtype = qtype;
+    question->domain[0] = len;
+    question->cls = 1;
+    memcpy(question->domain + 1, domain, len);
+}
+
+bool read_question(PacketBuffer* buffer, Question* question) {
+    buffer_read_qname(buffer, &question->domain);
+    
+    uint16_t qtype_num = buffer_read_short(buffer);
+    record_from_id(qtype_num, &question->qtype);
+    question->cls = buffer_read_short(buffer);
+
+    if (question->qtype == UNKOWN) {
+        free(question->domain);
+        return false;
+    }
+
+    return true;
+}
+
+void write_question(PacketBuffer* buffer, Question* question) {
+    buffer_write_qname(buffer, question->domain);
+    
+    uint16_t id = record_to_id(question->qtype);
+    buffer_write_short(buffer, id);
+
+    buffer_write_short(buffer, question->cls);
+}
+
+void free_question(Question* question) {
+    free(question->domain);
+}
+
+static const char* class_to_str(Question* question) {
+    switch(question->cls) {
+        case 1: return "IN";
+        case 3: return "CH";
+        case 4: return "HS";
+        default: return "??";
+    }
+}
+
+static const char* qtype_to_str(Question* question) {
+    switch(question->qtype) {
+        case A: return "A";
+        case NS: return "NS";
+        case CNAME: return "CNAME";
+        case SOA: return "SOA";
+        case PTR: return "PTR";
+        case MX: return "MX";
+        case TXT: return "TXT";
+        case AAAA: return "AAAA";
+        case SRV: return "SRV";
+        case CAA: return "CAA";
+        default: return "UNKOWN";
+    }
+}
+
+void print_question(Question* question) {
+    printf("%.*s.\t%s %s\n",
+        question->domain[0],
+        question->domain + 1,
+        class_to_str(question),
+        qtype_to_str(question)
+    );
+}
diff --git a/src/packet/question.h b/src/packet/question.h
new file mode 100644
index 0000000..9f5dde7
--- /dev/null
+++ b/src/packet/question.h
@@ -0,0 +1,16 @@
+#pragma once
+
+#include "buffer.h"
+#include "record.h"
+
+typedef struct {
+    uint8_t* domain;
+    RecordType qtype;
+    uint16_t cls;
+} Question;
+
+void create_question(const char* domain, RecordType qtype, Question* question);
+bool read_question(PacketBuffer* buffer, Question* question);
+void write_question(PacketBuffer* buffer, Question* question);
+void free_question(Question* question);
+void print_question(Question* question);
diff --git a/src/packet/record.c b/src/packet/record.c
new file mode 100644
index 0000000..ba3186a
--- /dev/null
+++ b/src/packet/record.c
@@ -0,0 +1,608 @@
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#undef _POSIX_C_SOURCE
+#include <stdio.h>
+
+#include "record.h"
+#include "buffer.h"
+
+uint16_t record_to_id(RecordType type) {
+    switch (type) {
+        case A:
+            return 1;
+        case NS:
+            return 2;
+        case CNAME:
+            return 5;
+        case SOA:
+            return 6;
+        case PTR:
+            return 12;
+        case MX:
+            return 15;
+        case TXT:
+            return 16;
+        case AAAA:
+            return 28;
+        case SRV:
+            return 33;
+        case CAA:
+            return 257;
+        default:
+            return 0;
+    }
+}
+
+void record_from_id(uint16_t i, RecordType* type) {
+    switch (i) {
+        case 1:
+            *type = A;
+            break;
+        case 2:
+            *type = NS;
+            break;
+        case 5:
+            *type = CNAME;
+            break;
+        case 6:
+            *type = SOA;
+            break;
+        case 12:
+            *type = PTR;
+            break;
+        case 15:
+            *type = MX;
+            break;
+        case 16:
+            *type = TXT;
+            break;
+        case 28:
+            *type = AAAA;
+            break;
+        case 33:
+            *type = SRV;
+            break;
+        case 257:
+            *type = CAA;
+            break;
+        default:
+            *type = UNKOWN;
+    }
+}
+
+bool str_to_qtype(const char* qstr, RecordType* qtype) {
+    if (strcasecmp(qstr, "A") == 0) {
+        *qtype = A;
+        return true;
+    } else if (strcasecmp(qstr, "NS") == 0) {
+        *qtype = NS;
+        return true;
+    } else if (strcasecmp(qstr, "CNAME") == 0) {
+        *qtype = CNAME;
+        return true;
+    } else if (strcasecmp(qstr, "SOA") == 0) {
+        *qtype = SOA;
+        return true;
+    } else if (strcasecmp(qstr, "PTR") == 0) {
+        *qtype = PTR;
+        return true;
+    } else if (strcasecmp(qstr, "MX") == 0) {
+        *qtype = MX;
+        return true;
+    } else if (strcasecmp(qstr, "TXT") == 0) {
+        *qtype = TXT;
+        return true;
+    } else if (strcasecmp(qstr, "AAAA") == 0) {
+        *qtype = AAAA;
+        return true;
+    } else if (strcasecmp(qstr, "SRV") == 0) {
+        *qtype = SRV;
+        return true;
+    } else if (strcasecmp(qstr, "CAA") == 0) {
+        *qtype = CAA;
+        return true;
+    } else { 
+        return false;
+    }
+    return false;
+}
+
+static void read_a_record(PacketBuffer* buffer, Record* record) {
+    ARecord data;
+    data.addr[0] = buffer_read(buffer);
+    data.addr[1] = buffer_read(buffer);
+    data.addr[2] = buffer_read(buffer);
+    data.addr[3] = buffer_read(buffer);
+
+    record->data.a = data;
+}
+
+static void read_ns_record(PacketBuffer* buffer, Record* record) {
+    NSRecord data;
+    buffer_read_qname(buffer, &data.host);
+
+    record->data.ns = data;
+}
+
+static void read_cname_record(PacketBuffer* buffer, Record* record) {
+    CNAMERecord data;
+    buffer_read_qname(buffer, &data.host);
+
+    record->data.cname = data;
+}
+
+static void read_soa_record(PacketBuffer* buffer, Record* record) {
+    SOARecord data;
+    buffer_read_qname(buffer, &data.mname);
+    buffer_read_qname(buffer, &data.nname);
+    data.serial = buffer_read_int(buffer);
+    data.refresh = buffer_read_int(buffer);
+    data.retry = buffer_read_int(buffer);
+    data.expire = buffer_read_int(buffer);
+    data.minimum = buffer_read_int(buffer);
+
+    record->data.soa = data;
+}
+
+static void read_ptr_record(PacketBuffer* buffer, Record* record) {
+    PTRRecord data;
+    buffer_read_qname(buffer, &data.pointer);
+
+    record->data.ptr = data;
+}
+
+static void read_mx_record(PacketBuffer* buffer, Record* record) {
+    MXRecord data;
+    data.priority = buffer_read_short(buffer);
+    buffer_read_qname(buffer, &data.host);
+
+    record->data.mx = data;
+}
+
+static void read_txt_record(PacketBuffer* buffer, Record* record) {
+    TXTRecord data;
+    data.len = 0;
+    data.text = malloc(sizeof(uint8_t*) * 2);
+    uint8_t capacity = 2;
+    uint8_t total = record->len;
+    while (1) {
+        if (data.len >= capacity) {
+            if (capacity >= 128) {
+                capacity = 255;
+            } else {
+                capacity *= 2;
+            }
+            data.text = realloc(data.text, sizeof(uint8_t*) * capacity);
+        }
+
+        buffer_read_string(buffer, &data.text[data.len]);
+        if(data.text[data.len][0] == 0) {
+            free(data.text[data.len]);
+            break;
+        }
+
+        data.len++;
+
+        total -= data.text[data.len - 1][0] + 1;
+        if (total == 0) break;
+    }
+
+    record->data.txt = data;
+}
+
+static void read_aaaa_record(PacketBuffer* buffer, Record* record) {
+    AAAARecord data;
+    for (int i = 0; i < 16; i++) {
+        data.addr[i] = buffer_read(buffer);
+    }
+
+    record->data.aaaa = data;
+}
+
+static void read_srv_record(PacketBuffer* buffer, Record* record) {
+    SRVRecord data;
+    data.priority = buffer_read_short(buffer);
+    data.weight = buffer_read_short(buffer);
+    data.port = buffer_read_short(buffer);
+    buffer_read_qname(buffer, &data.target);
+
+    record->data.srv = data;
+}
+
+static void read_caa_record(PacketBuffer* buffer, Record* record, int header_pos) {
+    CAARecord data;
+    data.flags = buffer_read(buffer);
+    data.length = buffer_read(buffer);
+    buffer_read_n(buffer, &data.tag, data.length);
+    int value_len = ((int)record->len) + header_pos - buffer_get_index(buffer);
+    buffer_read_n(buffer, &data.value, (uint8_t)value_len);
+
+    record->data.caa = data;
+}
+
+bool read_record(PacketBuffer* buffer, Record* record) {
+    buffer_read_qname(buffer, &record->domain);
+
+    uint16_t qtype_num = buffer_read_short(buffer);
+    record_from_id(qtype_num, &record->type);
+
+    record->cls = buffer_read_short(buffer);
+    record->ttl = buffer_read_int(buffer);
+    record->len = buffer_read_short(buffer);
+
+    int header_pos = buffer_get_index(buffer);
+
+    switch (record->type) {
+        case A:
+            read_a_record(buffer, record);
+            break;
+        case NS:
+            read_ns_record(buffer, record);
+            break;
+        case CNAME:
+            read_cname_record(buffer, record);
+            break;
+        case SOA:
+            read_soa_record(buffer, record);
+            break;
+        case PTR:
+            read_ptr_record(buffer, record);
+            break;
+        case MX:
+            read_mx_record(buffer, record);
+            break;
+        case TXT:
+            read_txt_record(buffer, record);
+            break;
+        case AAAA:
+            read_aaaa_record(buffer, record);
+            break;
+        case SRV:
+            read_srv_record(buffer, record);
+            break;
+        case CAA:
+            read_caa_record(buffer, record, header_pos);
+            break;
+        default:
+            buffer_step(buffer, record->len);
+            free(record->domain);
+            return false;
+    }
+
+    return true;
+}
+
+static void write_a_record(PacketBuffer* buffer, ARecord* data) {
+    buffer_write_short(buffer, 4);
+    buffer_write(buffer, data->addr[0]);
+    buffer_write(buffer, data->addr[1]);
+    buffer_write(buffer, data->addr[2]);
+    buffer_write(buffer, data->addr[3]);
+}
+
+static void write_ns_record(PacketBuffer* buffer, NSRecord* data) {
+    int pos = buffer_get_index(buffer);
+    buffer_write_short(buffer, 0);
+
+    buffer_write_qname(buffer, data->host);
+
+    int size = buffer_get_index(buffer) - pos - 2;
+    buffer_set_uint16_t(buffer, (uint16_t)size, pos);
+}
+
+static void write_cname_record(PacketBuffer* buffer, CNAMERecord* data) {
+    int pos = buffer_get_index(buffer);
+    buffer_write_short(buffer, 0);
+
+    buffer_write_qname(buffer, data->host);
+
+    int size = buffer_get_index(buffer) - pos - 2;
+    buffer_set_uint16_t(buffer, (uint16_t)size, pos);
+}
+
+static void write_soa_record(PacketBuffer* buffer, SOARecord* data) {
+    int pos = buffer_get_index(buffer);
+    buffer_write_short(buffer, 0);
+
+    buffer_write_qname(buffer, data->mname);
+    buffer_write_qname(buffer, data->nname);
+    buffer_write_int(buffer, data->serial);
+    buffer_write_int(buffer, data->refresh);
+    buffer_write_int(buffer, data->retry);
+    buffer_write_int(buffer, data->expire);
+    buffer_write_int(buffer, data->minimum);
+
+    int size = buffer_get_index(buffer) - pos - 2;
+    buffer_set_uint16_t(buffer, (uint16_t)size, pos);
+}
+
+static void write_ptr_record(PacketBuffer* buffer, PTRRecord* data) {
+    int pos = buffer_get_index(buffer);
+    buffer_write_short(buffer, 0);
+
+    buffer_write_qname(buffer, data->pointer);
+
+    int size = buffer_get_index(buffer) - pos - 2;
+    buffer_set_uint16_t(buffer, (uint16_t)size, pos);
+}
+
+static void write_mx_record(PacketBuffer* buffer, MXRecord* data) {
+    int pos = buffer_get_index(buffer);
+    buffer_write_short(buffer, 0);
+
+    buffer_write_short(buffer, data->priority);
+    buffer_write_qname(buffer, data->host);
+
+    int size = buffer_get_index(buffer) - pos - 2;
+    buffer_set_uint16_t(buffer, (uint16_t)size, pos);
+}
+
+static void write_txt_record(PacketBuffer* buffer, TXTRecord* data) {
+    int pos = buffer_get_index(buffer);
+    buffer_write_short(buffer, 0);
+
+    if(data->len == 0) {
+        return;
+    }
+
+    for(uint8_t i = 0; i < data->len; i++) {
+        buffer_write_string(buffer, data->text[i]);
+    }
+
+    int size = buffer_get_index(buffer) - pos - 2;
+    buffer_set_uint16_t(buffer, (uint16_t)size, pos);
+}
+
+static void write_aaaa_record(PacketBuffer* buffer, AAAARecord* data) {
+    buffer_write_short(buffer, 16);
+
+    for (int i = 0; i < 16; i++) {
+        buffer_write(buffer, data->addr[i]);
+    }
+}
+
+static void write_srv_record(PacketBuffer* buffer, SRVRecord* data) {
+    int pos = buffer_get_index(buffer);
+    buffer_write_short(buffer, 0);
+
+    buffer_write_short(buffer, data->priority);
+    buffer_write_short(buffer, data->weight);
+    buffer_write_short(buffer, data->port);
+    buffer_write_qname(buffer, data->target);
+
+    int size = buffer_get_index(buffer) - pos - 2;
+    buffer_set_uint16_t(buffer, (uint16_t)size, pos);
+}
+
+static void write_caa_record(PacketBuffer* buffer, CAARecord* data) {
+    int pos = buffer_get_index(buffer);
+    buffer_write_short(buffer, 0);
+    buffer_write(buffer, data->flags);
+    buffer_write(buffer, data->length);
+    buffer_write_n(buffer, data->tag + 1, data->tag[0]);
+    buffer_write_n(buffer, data->value + 1, data->value[0]);
+
+    int size = buffer_get_index(buffer) - pos - 2;
+    buffer_set_uint16_t(buffer, (uint16_t)size, pos);
+}
+
+static void write_record_header(PacketBuffer* buffer, Record* record) {
+    buffer_write_qname(buffer, record->domain);
+    uint16_t id = record_to_id(record->type);
+    buffer_write_short(buffer, id);
+    buffer_write_short(buffer, record->cls);
+    buffer_write_int(buffer, record->ttl);
+}
+
+void write_record(PacketBuffer* buffer, Record* record) {
+    switch(record->type) {
+        case A:
+            write_record_header(buffer, record);
+            write_a_record(buffer, &record->data.a);
+            break; 
+        case NS:
+            write_record_header(buffer, record);
+            write_ns_record(buffer, &record->data.ns);
+            break;
+        case CNAME:
+            write_record_header(buffer, record);
+            write_cname_record(buffer, &record->data.cname);
+            break;
+        case SOA:
+            write_record_header(buffer, record);
+            write_soa_record(buffer, &record->data.soa);
+            break;
+        case PTR:
+            write_record_header(buffer, record);
+            write_ptr_record(buffer, &record->data.ptr);
+            break;
+        case MX:
+            write_record_header(buffer, record);
+            write_mx_record(buffer, &record->data.mx);
+            break;
+        case TXT:
+            write_record_header(buffer, record);
+            write_txt_record(buffer, &record->data.txt);
+            break;
+        case AAAA:
+            write_record_header(buffer, record);
+            write_aaaa_record(buffer, &record->data.aaaa);
+            break;
+        case SRV:
+            write_record_header(buffer, record);
+            write_srv_record(buffer, &record->data.srv);
+            break;
+        case CAA:
+            write_record_header(buffer, record);
+            write_caa_record(buffer, &record->data.caa);
+            break;
+        default:
+            break;
+    }
+
+}
+
+void free_record(Record* record) {
+    free(record->domain);
+    switch (record->type) {
+        case NS:
+            free(record->data.ns.host);
+            break;
+        case CNAME:
+            free(record->data.cname.host);
+            break;
+        case SOA:
+            free(record->data.soa.mname);
+            free(record->data.soa.nname);
+            break;
+        case PTR:
+            free(record->data.ptr.pointer);
+            break;
+        case MX:
+            free(record->data.mx.host);
+            break;
+        case TXT:
+            for (uint8_t i = 0; i < record->data.txt.len; i++) {
+                free(record->data.txt.text[i]);
+            }
+            free(record->data.txt.text);
+            break;
+        case SRV:
+            free(record->data.srv.target);
+            break;
+        case CAA:
+            free(record->data.caa.value);
+            free(record->data.caa.tag);
+            break;
+        default:
+            break;
+        }
+}
+
+static const char* class_to_str(Record* record) {
+    switch(record->cls) {
+        case 1: return "IN";
+        case 3: return "CH";
+        case 4: return "HS";
+        default: return "??";
+    }
+}
+
+static const char* qtype_to_str(Record* record) {
+    switch(record->type) {
+        case A: return "A";
+        case NS: return "NS";
+        case CNAME: return "CNAME";
+        case SOA: return "SOA";
+        case PTR: return "PTR";
+        case MX: return "MX";
+        case TXT: return "TXT";
+        case AAAA: return "AAAA";
+        case SRV: return "SRV";
+        case CAA: return "CAA";
+        default: return "UNKOWN";
+    }
+}
+
+static void print_record_data(Record* record) {
+    switch(record->type) {
+        case A:
+            printf("%hhu.%hhu.%hhu.%hhu",
+                record->data.a.addr[0],
+                record->data.a.addr[1],
+                record->data.a.addr[2],
+                record->data.a.addr[3]
+            );
+            break;
+        case NS:
+            printf("%.*s",
+                record->data.ns.host[0],
+                record->data.ns.host + 1
+            );
+            break;
+        case CNAME:
+            printf("%.*s",
+                record->data.cname.host[0],
+                record->data.cname.host + 1
+            );
+            break;
+        case SOA:
+            printf("%.*s %.*s %u %u %u %u %u",
+                record->data.soa.mname[0],
+                record->data.soa.mname + 1,
+                record->data.soa.nname[0],
+                record->data.soa.nname + 1,
+                record->data.soa.serial,
+                record->data.soa.refresh,
+                record->data.soa.retry,
+                record->data.soa.expire,
+                record->data.soa.minimum
+            );
+            break;
+        case PTR:
+            printf("%.*s",
+                record->data.ptr.pointer[0],
+                record->data.ptr.pointer + 1
+            );
+            break;
+        case MX:
+            printf("%.*s %hu",
+                record->data.mx.host[0],
+                record->data.mx.host + 1,
+                record->data.mx.priority
+            );
+            break;
+        case TXT:
+            for(uint8_t i = 0; i < record->data.txt.len; i++) {
+                printf("%.*s",
+                    record->data.txt.text[i][0],
+                    record->data.txt.text[i] + 1
+                );
+            }
+            break;
+        case AAAA:
+            for(int i = 0; i < 8; i++) {
+                printf("%02hhx%02hhx:",
+                    record->data.a.addr[i*2 + 0],
+                    record->data.a.addr[i*2 + 1]
+                );
+            }
+            printf(":");
+            break;
+        case SRV:
+            printf("SRV (%hu %hu %hu %.*s",
+                record->data.srv.priority,
+                record->data.srv.weight,
+                record->data.srv.port,
+                record->data.srv.target[0],
+                record->data.srv.target + 1
+            );
+            break;
+        case CAA:
+            printf("%hhu %.*s %.*s",
+                record->data.caa.flags,
+                record->data.caa.tag[0],
+                record->data.caa.tag + 1,
+                record->data.caa.value[0],
+                record->data.caa.value + 1
+            );
+            break;
+        default:
+            break;
+    } 
+}
+
+void print_record(Record* record) {
+    printf("%.*s.\t%s %s\t",
+        record->domain[0],
+        record->domain + 1,
+        class_to_str(record),
+        qtype_to_str(record)
+    );
+    print_record_data(record);
+    printf("\n");
+}
diff --git a/src/packet/record.h b/src/packet/record.h
new file mode 100644
index 0000000..ac29cae
--- /dev/null
+++ b/src/packet/record.h
@@ -0,0 +1,108 @@
+#pragma once
+
+#include "buffer.h"
+
+#include <string.h>
+#include <stdbool.h>
+
+typedef enum {
+    UNKOWN,
+    A,      // 1
+    NS,     // 2
+    CNAME,  // 5
+    SOA,    // 6
+    PTR,    // 12
+    MX,     // 15
+    TXT,    // 16
+    AAAA,   // 28
+    SRV,    // 33
+    CAA    // 257
+} RecordType;
+
+uint16_t record_to_id(RecordType type);
+void record_from_id(uint16_t i, RecordType* type);
+
+typedef struct {
+    uint8_t addr[4];
+} ARecord;
+
+typedef struct {
+    uint8_t* host;
+} NSRecord;
+
+typedef struct {
+    uint8_t* host;
+} CNAMERecord;
+
+typedef struct {
+    uint8_t* mname;
+    uint8_t* nname;
+    uint32_t serial;
+    uint32_t refresh;
+    uint32_t retry;
+    uint32_t expire;
+    uint32_t minimum;
+} SOARecord;
+
+typedef struct {
+    uint8_t* pointer;
+} PTRRecord;
+
+typedef struct {
+    uint16_t priority;
+    uint8_t* host;
+} MXRecord;
+
+typedef struct TXTRecord {
+    uint8_t** text;
+    uint8_t len;
+} TXTRecord;
+
+typedef struct {
+    uint8_t addr[16];
+} AAAARecord;
+
+typedef struct {
+    uint16_t priority;
+    uint16_t weight;
+    uint16_t port;
+    uint8_t* target;
+} SRVRecord;
+
+typedef struct {
+    uint8_t flags;
+    uint8_t length;
+    uint8_t* tag;
+    uint8_t* value;
+} CAARecord;
+
+typedef struct {
+    char* command;
+} CMDRecord;
+
+typedef struct {
+    uint32_t ttl;
+    uint16_t cls;
+    uint16_t len;
+    uint8_t* domain;
+    RecordType type;
+    union data {
+        ARecord a;
+        NSRecord ns;
+        CNAMERecord cname;
+        SOARecord soa;
+        PTRRecord ptr;
+        MXRecord mx;
+        TXTRecord txt;
+        AAAARecord aaaa;
+        SRVRecord srv;
+        CAARecord caa;
+        CMDRecord cmd;
+    } data;
+} Record;
+
+bool read_record(PacketBuffer* buffer, Record* record);
+void write_record(PacketBuffer* buffer, Record* record);
+void free_record(Record* record);
+void print_record(Record* record);
+bool str_to_qtype(const char* str, RecordType* type);