summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/client/addr.c254
-rw-r--r--src/client/addr.h69
-rw-r--r--src/client/binding.c167
-rw-r--r--src/client/binding.h26
-rw-r--r--src/client/client.c177
-rw-r--r--src/client/client.h15
-rw-r--r--src/main.c112
-rw-r--r--src/packet/buffer.c247
-rw-r--r--src/packet/buffer.h51
-rw-r--r--src/packet/header.c108
-rw-r--r--src/packet/header.h42
-rw-r--r--src/packet/packet.c184
-rw-r--r--src/packet/packet.h25
-rw-r--r--src/packet/question.c79
-rw-r--r--src/packet/question.h16
-rw-r--r--src/packet/record.c608
-rw-r--r--src/packet/record.h108
17 files changed, 2288 insertions, 0 deletions
diff --git a/src/client/addr.c b/src/client/addr.c
new file mode 100644
index 0000000..82f0e2e
--- /dev/null
+++ b/src/client/addr.c
@@ -0,0 +1,254 @@
+#include <errno.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <netdb.h>
+#include <poll.h>
+
+#include "addr.h"
+
+void create_ip_addr(uint8_t* domain, IpAddr* addr) {
+ addr->type = V4;
+ memcpy(&addr->data.v4, domain, 4);
+}
+
+void create_ip_addr6(uint8_t* domain, IpAddr* addr) {
+ addr->type = V6;
+ memcpy(&addr->data.v6, domain, 16);
+}
+
+void ip_addr_any(IpAddr* addr) {
+ addr->type = V4;
+ addr->data.v4.s_addr = htonl(INADDR_ANY);
+}
+
+void ip_addr_any6(IpAddr* addr) {
+ addr->type = V6;
+ addr->data.v6 = in6addr_any;
+}
+
+bool ip_addr_name(const char* hostname, IpAddr* addr) {
+
+ struct hostent *he;
+ struct in_addr **addr_list;
+ int i;
+
+ if ((he = gethostbyname(hostname)) == NULL) {
+ return false;
+ }
+
+ addr_list = (struct in_addr **) he->h_addr_list;
+
+ for(i = 0; addr_list[i] != NULL; i++) {
+ addr->data.v4 = *addr_list[i];
+ addr->type = V4;
+ return true;
+ }
+
+ return false;
+}
+
+static struct sockaddr_in create_socket_addr_v4(IpAddr addr, uint16_t port) {
+ struct sockaddr_in socketaddr;
+ memset(&socketaddr, 0, sizeof(socketaddr));
+ socketaddr.sin_family = AF_INET;
+ socketaddr.sin_port = htons(port);
+ socketaddr.sin_addr = addr.data.v4;
+ return socketaddr;
+}
+
+static struct sockaddr_in6 create_socket_addr_v6(IpAddr addr, uint16_t port) {
+ struct sockaddr_in6 socketaddr;
+ memset(&socketaddr, 0, sizeof(socketaddr));
+ socketaddr.sin6_family = AF_INET6;
+ socketaddr.sin6_port = htons(port);
+ socketaddr.sin6_addr = addr.data.v6;
+ return socketaddr;
+}
+
+static size_t get_addr_len(AddrType type) {
+ if (type == V4) {
+ return sizeof(struct sockaddr_in);
+ } else if (type == V6) {
+ return sizeof(struct sockaddr_in6);
+ } else {
+ return 0;
+ }
+}
+
+void create_socket_addr(uint16_t port, IpAddr addr, SocketAddr* socket) {
+ socket->type = addr.type;
+ if (addr.type == V4) {
+ socket->data.v4 = create_socket_addr_v4(addr, port);
+ } else if(addr.type == V6) {
+ socket->data.v6 = create_socket_addr_v6(addr, port);
+ } else {
+ exit(EXIT_FAILURE);
+ }
+ socket->len = get_addr_len(addr.type);
+}
+
+#define ADDR_DOMAIN(addr, var) \
+ struct sockaddr* var; \
+ if (addr->type == V4) { \
+ var = (struct sockaddr*) &addr->data.v4; \
+ } else if (addr->type == V6) { \
+ var = (struct sockaddr*) &addr->data.v6; \
+ } else { \
+ return -1; \
+ }
+
+#define ADDR_AFNET(type, var) \
+ int var; \
+ if (type == V4) { \
+ var = AF_INET; \
+ } else if (type == V6) { \
+ var = AF_INET6; \
+ } else { \
+ return -1; \
+ }
+
+int32_t create_udp_socket(AddrType type, UdpSocket* sock) {
+ ADDR_AFNET(type, __domain)
+ sock->type = type;
+ sock->sockfd = socket(__domain, SOCK_DGRAM, 0);
+ return sock->sockfd;
+}
+
+int32_t bind_udp_socket(SocketAddr* addr, UdpSocket* sock) {
+ if (addr->type == V6) {
+ int v6OnlyEnabled = 0;
+ int32_t res = setsockopt(
+ sock->sockfd,
+ IPPROTO_IPV6,
+ IPV6_V6ONLY,
+ &v6OnlyEnabled,
+ sizeof(v6OnlyEnabled)
+ );
+ if (res < 0) return res;
+ }
+ ADDR_DOMAIN(addr, __addr)
+ return bind(sock->sockfd, __addr, addr->len);
+}
+
+static bool timeout (int connfd, int ms) {
+ struct pollfd fd;
+ int res;
+
+ fd.fd = connfd;
+ fd.events = POLLIN;
+ res = poll(&fd, 1, ms);
+ return res == 0;
+}
+
+int32_t read_udp_socket(UdpSocket* socket, void* buffer, uint16_t len, SocketAddr* clientaddr) {
+ clientaddr->type = socket->type;
+ clientaddr->len = get_addr_len(socket->type);
+ ADDR_DOMAIN(clientaddr, __addr)
+ if (timeout(socket->sockfd, 1000)) {
+ errno = ETIMEDOUT;
+ return -1;
+ }
+ return recvfrom(
+ socket->sockfd,
+ buffer,
+ (size_t) len,
+ MSG_WAITALL,
+ __addr,
+ (uint32_t*) &clientaddr->len
+ );
+}
+
+int32_t write_udp_socket(UdpSocket* socket, void* buffer, uint16_t len, SocketAddr* clientaddr) {
+ ADDR_DOMAIN(clientaddr, __addr)
+ return sendto(
+ socket->sockfd,
+ buffer,
+ (size_t) len,
+ MSG_CONFIRM,
+ __addr,
+ (uint32_t) clientaddr->len
+ );
+}
+
+int32_t close_udp_socket(UdpSocket* socket) {
+ return close(socket->sockfd);
+}
+
+int32_t create_tcp_socket(AddrType type, TcpSocket* sock) {
+ ADDR_AFNET(type, __domain)
+ sock->type = type;
+ sock->sockfd = socket(__domain, SOCK_STREAM, 0);
+ return sock->sockfd;
+}
+
+int32_t bind_tcp_socket(SocketAddr* addr, TcpSocket* sock) {
+ if (addr->type == V6) {
+ int v6OnlyEnabled = 0;
+ int32_t res = setsockopt(
+ sock->sockfd,
+ IPPROTO_IPV6,
+ IPV6_V6ONLY,
+ &v6OnlyEnabled,
+ sizeof(v6OnlyEnabled)
+ );
+ if (res < 0) return res;
+ }
+ ADDR_DOMAIN(addr, __addr)
+ return bind(sock->sockfd, __addr, addr->len);
+}
+
+int32_t listen_tcp_socket(TcpSocket* socket, uint32_t max) {
+ return listen(socket->sockfd, max);
+}
+
+int32_t accept_tcp_socket(TcpSocket* socket, TcpStream* stream) {
+ stream->clientaddr.type = socket->type;
+ memset(&stream->clientaddr, 0, sizeof(SocketAddr));
+ SocketAddr* addr = &stream->clientaddr;
+ ADDR_DOMAIN(addr, __addr)
+ stream->streamfd = accept(
+ socket->sockfd,
+ __addr,
+ (uint32_t*) &stream->clientaddr.len
+ );
+ return stream->streamfd;
+}
+
+int32_t close_tcp_socket(TcpSocket* socket) {
+ return close(socket->sockfd);
+}
+
+int32_t connect_tcp_stream(SocketAddr* servaddr, TcpStream* stream) {
+ TcpSocket socket;
+ int32_t res = create_tcp_socket(servaddr->type, &socket);
+ if (res < 0) return res;
+ stream->clientaddr = *servaddr;
+ stream->streamfd = socket.sockfd;
+ ADDR_DOMAIN(servaddr, __addr)
+ return connect(
+ socket.sockfd,
+ __addr,
+ servaddr->len
+ );
+}
+
+int32_t read_tcp_stream(TcpStream* stream, void* buffer, uint16_t len) {
+ if (timeout(stream->streamfd, 3000)) {
+ errno = ETIMEDOUT;
+ return -1;
+ }
+ return recv(stream->streamfd, buffer, len, MSG_WAITALL);
+}
+
+int32_t write_tcp_stream(TcpStream* stream, void* buffer, uint16_t len) {
+ return send(stream->streamfd, buffer, len, MSG_NOSIGNAL);
+}
+
+int32_t close_tcp_stream(TcpStream* stream) {
+ return close(stream->streamfd);
+}
diff --git a/src/client/addr.h b/src/client/addr.h
new file mode 100644
index 0000000..28c6066
--- /dev/null
+++ b/src/client/addr.h
@@ -0,0 +1,69 @@
+#pragma once
+
+#include "../packet/record.h"
+
+#include <string.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+
+typedef enum {
+ V4,
+ V6
+} AddrType;
+
+typedef struct {
+ AddrType type;
+ union {
+ struct in_addr v4;
+ struct in6_addr v6;
+ } data;
+} IpAddr;
+
+void create_ip_addr(uint8_t* domain, IpAddr* addr);
+void create_ip_addr6(uint8_t* domain, IpAddr* addr);
+void ip_addr_any(IpAddr* addr);
+void ip_addr_any6(IpAddr* addr);
+bool ip_addr_name(const char* name, IpAddr* addr);
+
+typedef struct {
+ AddrType type;
+ union {
+ struct sockaddr_in v4;
+ struct sockaddr_in6 v6;
+ } data;
+ size_t len;
+} SocketAddr;
+
+void create_socket_addr(uint16_t port, IpAddr addr, SocketAddr* socket);
+
+typedef struct {
+ AddrType type;
+ uint32_t sockfd;
+} UdpSocket;
+
+int32_t create_udp_socket(AddrType type, UdpSocket* socket);
+int32_t bind_udp_socket(SocketAddr* addr, UdpSocket* socket);
+int32_t read_udp_socket(UdpSocket* socket, void* buffer, uint16_t len, SocketAddr* clientaddr);
+int32_t write_udp_socket(UdpSocket* socket, void* buffer, uint16_t len, SocketAddr* clientaddr);
+int32_t close_udp_socket(UdpSocket* socket);
+
+typedef struct {
+ AddrType type;
+ uint32_t sockfd;
+} TcpSocket;
+
+typedef struct {
+ SocketAddr clientaddr;
+ uint32_t streamfd;
+} TcpStream;
+
+int32_t create_tcp_socket(AddrType type, TcpSocket* socket);
+int32_t bind_tcp_socket(SocketAddr* addr, TcpSocket* socket);
+int32_t listen_tcp_socket(TcpSocket* socket, uint32_t max);
+int32_t accept_tcp_socket(TcpSocket* socket, TcpStream* stream);
+int32_t close_tcp_socket(TcpSocket* socket);
+int32_t connect_tcp_stream(SocketAddr* servaddr, TcpStream* stream);
+int32_t read_tcp_stream(TcpStream* stream, void* buffer, uint16_t len);
+int32_t write_tcp_stream(TcpStream* stream, void* buffer, uint16_t len);
+int32_t close_tcp_stream(TcpStream* stream);
diff --git a/src/client/binding.c b/src/client/binding.c
new file mode 100644
index 0000000..9917a50
--- /dev/null
+++ b/src/client/binding.c
@@ -0,0 +1,167 @@
+#include <ctype.h>
+#include <netinet/in.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+
+#include "addr.h"
+#include "binding.h"
+
+static void read_to_packet(uint8_t* buf, uint16_t len, Packet* packet) {
+ PacketBuffer* pkbuffer = buffer_create(len);
+ for (int i = 0; i < len; i++) {
+ buffer_write(pkbuffer, buf[i]);
+ }
+ buffer_seek(pkbuffer, 0);
+ read_packet(pkbuffer, packet);
+ buffer_free(pkbuffer);
+}
+
+static bool read_udp(Connection* connection, Packet* packet) {
+ uint8_t buffer[512];
+ int32_t n = read_udp_socket(
+ &connection->sock.udp.udp,
+ buffer,
+ 512,
+ &connection->sock.udp.clientaddr
+ );
+ if (n < 0) {
+ return false;
+ }
+ read_to_packet(buffer, n, packet);
+ return true;
+}
+
+static bool read_tcp(Connection* connection, Packet* packet) {
+ uint16_t len;
+ if ( read_tcp_stream(
+ &connection->sock.tcp,
+ &len,
+ sizeof(uint16_t)
+ ) < 2) {
+ return false;
+ }
+ len = ntohs(len);
+
+ uint8_t buffer[len];
+ if (read_tcp_stream(
+ &connection->sock.tcp,
+ buffer,
+ len
+ ) < len) {
+ return false;
+ }
+
+ read_to_packet(buffer, len, packet);
+ return true;
+}
+
+static bool read_connection(Connection* connection, Packet* packet) {
+ if (connection->type == UDP) {
+ return read_udp(connection, packet);
+ } else if (connection->type == TCP) {
+ return read_tcp(connection, packet);
+ }
+ return false;
+}
+
+static bool write_udp(Connection* connection, uint8_t* buf, uint16_t len) {
+ if (len > 512) {
+ buf[2] = buf[2] | 0x03;
+ len = 512;
+ }
+ return write_udp_socket(
+ &connection->sock.udp.udp,
+ buf,
+ len,
+ &connection->sock.udp.clientaddr
+ ) == len;
+}
+
+static bool write_tcp(Connection* connection, uint8_t* buf, uint16_t len) {
+ uint16_t net_len = htons(len);
+ if (write_tcp_stream(
+ &connection->sock.tcp,
+ &net_len,
+ sizeof(uint16_t)
+ ) < 0) {
+ return false;
+ }
+
+ if (write_tcp_stream(
+ &connection->sock.tcp,
+ buf,
+ len
+ ) < 0) {
+ return false;
+ }
+
+ return true;
+}
+
+static bool write_connection(Connection* connection, Packet* packet) {
+ PacketBuffer* pkbuffer = buffer_create(64);
+ write_packet(pkbuffer, packet);
+ uint16_t len = buffer_get_size(pkbuffer);
+ uint8_t* buffer = buffer_get_ptr(pkbuffer);
+ bool success = false;
+ if(connection->type == UDP) {
+ success = write_udp(connection, buffer, len);
+ } else if(connection->type == TCP) {
+ success = write_tcp(connection, buffer, len);
+ };
+ buffer_free(pkbuffer);
+ return success;
+}
+
+void free_connection(Connection* connection) {
+ if (connection->type == TCP) {
+ close_tcp_stream(&connection->sock.tcp);
+ }
+}
+
+static bool create_udp_request(SocketAddr* addr, Connection* request) {
+ if ( create_udp_socket(addr->type, &request->sock.udp.udp) < 0) {
+ return false;
+ }
+ request->sock.udp.clientaddr = *addr;
+ return true;
+}
+
+static bool create_tcp_request(SocketAddr* addr, Connection* request) {
+ if( connect_tcp_stream(addr, &request->sock.tcp) < 0) {
+ return false;
+ }
+ return true;
+}
+
+bool create_request(BindingType type, SocketAddr* addr, Connection* request) {
+ request->type = type;
+ if (type == UDP) {
+ return create_udp_request(addr, request);
+ } else if (type == TCP) {
+ return create_tcp_request(addr, request);
+ } else {
+ return true;
+ }
+}
+
+bool request_packet(Connection* request, Packet* in, Packet* out) {
+ if (!write_connection(request, in)) {
+ return false;
+ }
+ if (!read_connection(request, out)) {
+ return false;
+ }
+ return true;
+}
+
+void free_request(Connection* connection) {
+ if (connection->type == UDP) {
+ close_udp_socket(&connection->sock.udp.udp);
+ } else if (connection->type == TCP) {
+ close_tcp_stream(&connection->sock.tcp);
+ }
+}
diff --git a/src/client/binding.h b/src/client/binding.h
new file mode 100644
index 0000000..ea02c98
--- /dev/null
+++ b/src/client/binding.h
@@ -0,0 +1,26 @@
+#pragma once
+
+#include "../packet/packet.h"
+#include "addr.h"
+
+#include <netinet/in.h>
+
+typedef enum {
+ UDP,
+ TCP
+} BindingType;
+
+typedef struct {
+ BindingType type;
+ union {
+ struct {
+ UdpSocket udp;
+ SocketAddr clientaddr;
+ } udp;
+ TcpStream tcp;
+ } sock;
+} Connection;
+
+bool create_request(BindingType type, SocketAddr* addr, Connection* request);
+bool request_packet(Connection* request, Packet* in, Packet* out);
+void free_request(Connection* connection);
diff --git a/src/client/client.c b/src/client/client.c
new file mode 100644
index 0000000..31ef589
--- /dev/null
+++ b/src/client/client.c
@@ -0,0 +1,177 @@
+#include "client.h"
+#include "../packet/question.h"
+#include "addr.h"
+#include "binding.h"
+
+#include <resolv.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <string.h>
+#include <time.h>
+#include <errno.h>
+#include <sys/time.h>
+
+void resolve_default_server(IpAddr* addr) {
+ res_init();
+ addr->data.v4 = _res.nsaddr_list[0].sin_addr;
+ addr->type = V4;
+}
+
+static void push_question(Question** buf, Question q, uint8_t* amount, uint8_t* capacity) {
+ if (*amount >= *capacity) {
+ *capacity *= 2;
+ *buf = realloc(*buf, sizeof(Question) * *capacity);
+ }
+ (*buf)[*amount] = q;
+ (*amount)++;
+}
+
+void resolve_questions(int argc, char** argv, uint8_t* len, Question** questions) {
+ assert(argc > 0);
+
+ uint8_t amount = 0;
+ uint8_t capacity = 1;
+ Question* buf = malloc(sizeof(Question) * capacity);
+
+ Question q;
+ RecordType t;
+ if (argc == 1 && str_to_qtype(argv[0], &t)) {
+ create_question("", NS, &q);
+ push_question(&buf, q, &amount, &capacity);
+ *questions = buf;
+ *len = 1;
+ return;
+ }
+
+ for (int i = 0; i < argc; i++) {
+ if (str_to_qtype(argv[i], &t)) {
+ if (i + 1 == argc) break;
+ create_question(argv[i+1], t, &q);
+ i++;
+ } else if (i + 1 < argc && str_to_qtype(argv[i+1], &t)){
+ create_question(argv[i], t, &q);
+ i++;
+ } else {
+ create_question(argv[i], A, &q);
+ }
+ push_question(&buf, q, &amount, &capacity);
+ }
+
+ *questions = buf;
+ *len = amount;
+}
+
+static void print_result(Packet* packet, const char* type, uint32_t ms) {
+ printf(">> Recieved response\n");
+ printf("Id: %hu, Code: %s\n",
+ packet->header.id,
+ str_from_code(packet->header.rescode)
+ );
+ printf("Questions: %hu, Answers: %hu, Authorities: %hu, Resources: %hu\n",
+ packet->header.questions,
+ packet->header.answers,
+ packet->header.authoritative_entries,
+ packet->header.resource_entries
+ );
+
+ if (packet->header.questions > 0) {
+ printf("\n>> Question Section\n");
+ for (uint16_t i = 0; i < packet->header.questions; i++) {
+ print_question(&packet->questions[i]);
+ }
+ }
+
+ if (packet->header.answers > 0) {
+ printf("\n>> Answer Section\n");
+ for (uint16_t i = 0; i < packet->header.answers; i++) {
+ print_record(&packet->answers[i]);
+ }
+ }
+
+ if (packet->header.authoritative_entries > 0) {
+ printf("\n>> Authority Section\n");
+ for (uint16_t i = 0; i < packet->header.authoritative_entries; i++) {
+ print_record(&packet->authorities[i]);
+ }
+ }
+
+ if (packet->header.resource_entries > 0) {
+ printf("\n>> Resource Section\n");
+ for (uint16_t i = 0; i < packet->header.resource_entries; i++) {
+ print_record(&packet->resources[i]);
+ }
+ }
+
+ printf("\n>> Query time: %ums (%s)\n", ms, type);
+}
+
+void resolve(IpAddr server, Options options, Question* questions, uint8_t len) {
+ struct timeval stop, start;
+ gettimeofday(&start, NULL);
+
+ SocketAddr addr;
+ create_socket_addr(options.port, server, &addr);
+
+ Packet req;
+ memset(&req, 0, sizeof(Packet));
+ srand(time(NULL));
+ req.header.id = rand() % 65536;
+ req.header.questions = len;
+ req.header.recursion_desired = true;
+ req.questions = questions;
+
+ Connection conn;
+ if (options.force_tcp) goto tcp;
+
+ if (!create_request(UDP, &addr, &conn)) {
+ printf("error: failed to create udp request: %s\n", strerror(errno));
+ exit(EXIT_FAILURE);
+ }
+
+ Packet res;
+ if (!request_packet(&conn, &req, &res)) {
+ free_request(&conn);
+ free_packet(&req);
+ printf("error: failed to request udp packet: %s\n", strerror(errno));
+ exit(EXIT_FAILURE);
+ }
+
+ free_request(&conn);
+
+ if (!res.header.truncated_message) {
+ gettimeofday(&stop, NULL);
+ uint32_t ms = (stop.tv_sec - start.tv_sec) * 1000000 + stop.tv_usec - start.tv_usec;
+
+ print_result(&res, "UDP", ms / 1000);
+ free_packet(&req);
+ free_packet(&res);
+ return;
+ }
+
+ free_packet(&res);
+ printf("Response truncated, retrying in TCP...\n");
+
+tcp:
+
+ if (!create_request(TCP, &addr, &conn)) {
+ printf("error: failed to create tcp request: %s\n", strerror(errno));
+ exit(EXIT_FAILURE);
+ }
+
+ if (!request_packet(&conn, &req, &res)) {
+ free_request(&conn);
+ printf("error: failed to request tcp packet: %s\n", strerror(errno));
+ exit(EXIT_FAILURE);
+ }
+
+ gettimeofday(&stop, NULL);
+ uint32_t ms = (stop.tv_sec - start.tv_sec) * 1000000 + stop.tv_usec - start.tv_usec;
+
+ print_result(&res, "TCP", ms / 1000);
+
+ free_request(&conn);
+ free_packet(&req);
+ free_packet(&res);
+}
+
diff --git a/src/client/client.h b/src/client/client.h
new file mode 100644
index 0000000..7e0e391
--- /dev/null
+++ b/src/client/client.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#include "addr.h"
+#include "../packet/packet.h"
+
+typedef struct {
+ uint16_t port;
+ bool force_tcp;
+} Options;
+
+void resolve_default_server(IpAddr* addr);
+
+void resolve_questions(int argc, char** argv, uint8_t* len, Question** questions);
+
+void resolve(IpAddr server, Options options, Question* questions, uint8_t lem);
diff --git a/src/main.c b/src/main.c
new file mode 100644
index 0000000..454a8e8
--- /dev/null
+++ b/src/main.c
@@ -0,0 +1,112 @@
+#include "client/addr.h"
+#include "client/client.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/select.h>
+
+#define DEFAULT_PORT 53
+
+static void help() {
+ printf("wig: a simple dns client\n");
+ printf("usage: wig [@server] [options] domain [qtype]\n");
+ printf("arguments: \n");
+ printf("\t@server\t specify a dns server (@example.com)\n");
+ printf("\t-p\t specify a port (-p 2000)\n");
+ printf("\t-t\t force dns request to do tcp first\n");
+ exit(EXIT_SUCCESS);
+}
+
+static void parse_server (char* argv, char** server) {
+ if (*server != NULL) {
+ printf("error: only one dns server argument is allowed\n");
+ exit(EXIT_FAILURE);
+ }
+ if (strlen(argv) < 1) {
+ printf("error: dns server argument cannot be empty\n");
+ exit(EXIT_FAILURE);
+ }
+ *server = argv;
+}
+
+static int parse_arguent (int argc, char** argv, Options* options) {
+ if (strlen(argv[0]) < 2) {
+ printf("error: expected option after -\n");
+ exit(EXIT_FAILURE);
+ }
+
+ if (strcmp(argv[0], "-p") == 0) {
+ if (argc < 2) {
+ printf("error: expected port after -p\n");
+ exit(EXIT_FAILURE);
+ }
+ if ((options->port = strtoul(argv[1], NULL, 10)) == 0) {
+ printf("error: %s is not a valid port\n", argv[1]);
+ exit(EXIT_FAILURE);
+ }
+ return 1;
+ } else if (strcmp(argv[0], "-t") == 0) {
+ options->force_tcp = true;
+ return 0;
+ } else if (
+ strcmp(argv[0], "-h") == 0 ||
+ strcmp(argv[0], "--help") == 0
+ ) {
+ help();
+ }
+
+ printf("error: unkown option %s\n", argv[0]);
+ exit(EXIT_FAILURE);
+}
+
+int main(int argc, char** argv) {
+
+ if (argc < 1) return EXIT_FAILURE;
+
+ int dargs = 1;
+
+ char* server = NULL;
+ Options options;
+ options.port = DEFAULT_PORT;
+ options.force_tcp = false;
+
+ for (int i = 1; i < argc; i++) {
+ char s = argv[i][0];
+ if (s == '@') {
+ dargs++;
+ parse_server(argv[i] + 1, &server);
+ } else if (s == '-') {
+ int o = parse_arguent(argc - i, &argv[i], &options);
+ dargs++;
+ dargs += o;
+ i += o;
+ } else {
+ break;
+ }
+ }
+
+ if (argc - dargs < 1) {
+ printf("usage: wig [@server] [options] domain [qtype]\n");
+ return EXIT_FAILURE;
+ }
+
+ IpAddr addr;
+
+ if (server != NULL) {
+ if (!ip_addr_name(server, &addr)) {
+ printf("error: %s is not a valid domain\n", server);
+ exit(EXIT_FAILURE);
+ }
+ } else {
+ resolve_default_server(&addr);
+ }
+
+ Question* arr;
+ uint8_t len;
+
+ resolve_questions(argc - dargs, &argv[dargs], &len, &arr);
+ resolve(addr, options, arr, len);
+
+ return EXIT_SUCCESS;
+}
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);
generated by cgit v1.2.3-freya (git 2.51.0) at 2025-09-23 06:29:50 +0000