srctree

Gregory Mullen parent 08ddebc1 a1dbf38c
server listener

build.zig added: 74, removed: 29, total 45
@@ -25,6 +25,9 @@ pub fn build(b: *std.Build) void {
const client = b.addExecutable(.{ .name = "dnsc", .root_module = client_mod });
b.installArtifact(client);
 
const daemon = b.addExecutable(.{ .name = "dnsd", .root_module = daemon_mod });
b.installArtifact(daemon);
 
const run_cmd = b.addRunArtifact(client);
run_cmd.step.dependOn(b.getInstallStep());
if (b.args) |args| run_cmd.addArgs(args);
 
src/dns.zig added: 74, removed: 29, total 45
@@ -10,10 +10,10 @@ pub const Domains = struct {
 
pub const Message = struct {
header: Header,
question: ?[]Question = null,
answer: ?[]Resource = null,
authority: ?[]Resource = null,
additional: ?[]Resource = null,
questions: ?[]Question = null,
answers: ?[]Resource = null,
authorities: ?[]Resource = null,
additionals: ?[]Resource = null,
 
pub const Header = packed struct(u96) {
arcount: u16,
@@ -170,8 +170,8 @@ pub const Message = struct {
 
return .{
.header = header,
.question = questions,
.answer = resources,
.questions = questions,
.answers = resources,
};
}
 
@@ -197,28 +197,33 @@ pub const Message = struct {
.nscount = 0,
.arcount = 0,
},
.question = queries,
.questions = queries,
};
}
 
pub fn answer(domain: []const u8, ip: Address) !Message {
_ = domain;
_ = ip;
}
 
pub fn write(m: Message, buffer: []u8) !usize {
var fbs = std.io.fixedBufferStream(buffer);
var writer = fbs.writer();
var w = writer.any();
try w.writeInt(u96, @bitCast(m.header), .big);
if (m.question) |quest| for (quest) |q| {
if (m.questions) |quest| for (quest) |q| {
try q.write(&w);
};
 
if (m.answer) |answer| for (answer) |a| {
if (m.answers) |ans| for (ans) |a| {
a.write();
};
 
if (m.authority) |authort| for (authort) |a| {
if (m.authorities) |authort| for (authort) |a| {
a.write();
};
 
if (m.additional) |addit| for (addit) |a| {
if (m.additionals) |addit| for (addit) |a| {
a.write();
};
 
@@ -231,11 +236,11 @@ pub const Message = struct {
@as(u96, 37884113131630398792389361664),
@as(u96, @bitCast(q.header)),
);
for (q.question.?) |qst| {
for (q.questions.?) |qst| {
_ = qst;
//std.testing.allocator.free(qst.name);
}
std.testing.allocator.free(q.question.?);
std.testing.allocator.free(q.questions.?);
}
};
 
@@ -308,6 +313,11 @@ pub const Label = struct {
}
};
 
pub const Address = union(enum) {
a: [4]u8,
aaaa: [16]u8,
};
 
test "Message.Header" {
const thing: Message.Header = .{
.id = 16,
@@ -332,10 +342,10 @@ test "Message.Header" {
 
fn testVector(a: Allocator, vect: []const u8) !void {
const msg = try Message.fromBytes(a, vect);
try std.testing.expectEqual(1, msg.question.?.len);
try std.testing.expectEqual(1, msg.answer.?.len);
a.free(msg.question.?);
a.free(msg.answer.?);
try std.testing.expectEqual(1, msg.questions.?.len);
try std.testing.expectEqual(1, msg.answers.?.len);
a.free(msg.questions.?);
a.free(msg.answers.?);
}
 
test "build pkt" {
@@ -343,7 +353,7 @@ test "build pkt" {
const msg = try Message.query(a, &[1][]const u8{"gr.ht."});
var buffer: [23]u8 = undefined;
const used = try msg.write(&buffer);
a.free(msg.question.?);
a.free(msg.questions.?);
 
try std.testing.expect(used == 23);
 
@@ -362,7 +372,7 @@ test "build pkt non-fqdn" {
const msg = try Message.query(a, &[1][]const u8{"gr.ht"});
var buffer: [23]u8 = undefined;
const used = try msg.write(&buffer);
a.free(msg.question.?);
a.free(msg.questions.?);
 
try std.testing.expect(used == 23);
 
 
src/server.zig added: 74, removed: 29, total 45
@@ -1,18 +1,50 @@
pub fn server() !void {
const sock = try std.posix.socket(std.posix.AF.INET, std.posix.SOCK.DGRAM, std.posix.SOCK.NONBLOCK);
pub fn main() !void {
const a = std.heap.page_allocator;
var argsi = std.process.args();
while (argsi.next()) |arg| {
_ = arg;
}
 
const addr: std.net.Address = .{ .in = .{ .sa = .{
.port = 53,
.addr = 0,
.port = @byteSwap(@as(u16, 53)),
.addr = std.mem.readInt(u32, &[4]u8{ 127, 0, 0, 1 }, .little),
} } };
const sock = try std.posix.socket(std.posix.AF.INET, std.posix.SOCK.DGRAM, 0);
const bind = try std.posix.bind(sock, &addr.any, addr.getOsSockLen());
_ = bind;
 
const buffer: [1024]u8 = undefined;
const icnt = try std.posix.recv(sock, &buffer, 0);
std.debug.print("sent {}\n", .{icnt});
// nobody on my machine
if (std.os.linux.getuid() == 0) {
std.debug.print("dropping root\n", .{});
_ = try std.posix.setgid(99);
_ = try std.posix.setuid(99);
}
 
std.debug.print("started\n", .{});
 
//const msg = try DNS.Message.query(a, &[1][]const u8{domain orelse "gr.ht."});
//var request: [1024]u8 = undefined;
//const msgsize = try msg.write(&request);
 
var src_addr: std.net.Address = .{ .any = undefined };
var src_len: u32 = 0;
 
var buffer: [1024]u8 = undefined;
const icnt = try std.posix.recvfrom(sock, &buffer, 0, &src_addr.any, &src_len);
if (icnt >= 512) {
@panic("packet too large");
}
std.debug.print("received {}\n", .{icnt});
std.debug.print("data {any}\n", .{buffer[0..icnt]});
 
const msg = try DNS.Message.fromBytes(a, buffer[0..icnt]);
std.debug.print("data {any}\n", .{msg});
 
std.debug.print("done\n", .{});
}
 
const DNS = @import("dns.zig");
 
const std = @import("std");
const log = std.log;
const Allocator = std.mem.Allocator;