srctree

Gregory Mullen parent ba473d41 c4c2f5e4
seperate server and client

build.zig added: 79, removed: 66, total 13
@@ -4,7 +4,7 @@ pub fn build(b: *std.Build) void {
const target = b.standardTargetOptions(.{});
const optimize = b.standardOptimizeOption(.{});
 
const exe_mod = b.createModule(.{
const dns_mod = b.createModule(.{
.root_source_file = b.path("src/dns.zig"),
.target = target,
.optimize = optimize,
@@ -15,16 +15,21 @@ pub fn build(b: *std.Build) void {
.target = target,
.optimize = optimize,
});
_ = dnsc_mod;
 
const exe = b.addExecutable(.{
.name = "dnsc",
.root_module = exe_mod,
const dnsd_mod = b.createModule(.{
.root_source_file = b.path("src/server.zig"),
.target = target,
.optimize = optimize,
});
 
b.installArtifact(exe);
const exe_c = b.addExecutable(.{
.name = "dnsc",
.root_module = dnsc_mod,
});
 
const run_cmd = b.addRunArtifact(exe);
b.installArtifact(exe_c);
 
const run_cmd = b.addRunArtifact(exe_c);
 
run_cmd.step.dependOn(b.getInstallStep());
 
@@ -35,12 +40,10 @@ pub fn build(b: *std.Build) void {
const run_step = b.step("run", "Run the app");
run_step.dependOn(&run_cmd.step);
 
const exe_unit_tests = b.addTest(.{
.root_module = exe_mod,
});
 
const run_exe_unit_tests = b.addRunArtifact(exe_unit_tests);
 
const test_step = b.step("test", "Run unit tests");
test_step.dependOn(&run_exe_unit_tests.step);
inline for (.{ dns_mod, dnsc_mod, dnsd_mod }) |mod| {
const tests = b.addTest(.{ .root_module = mod });
const test_run = b.addRunArtifact(tests);
test_step.dependOn(&test_run.step);
}
}
 
src/client.zig added: 79, removed: 66, total 13
@@ -0,0 +1,37 @@
pub fn main() !void {
const a = std.heap.page_allocator;
std.debug.print("started\n", .{});
 
const addr: std.net.Address = .{ .in = .{ .sa = .{
.port = std.mem.nativeToBig(u16, 53),
.addr = std.mem.bytesToValue(u32, &[4]u8{ 0, 0, 0, 0 }),
} } };
 
const msg = try DNS.Message.query(a, &[1][]const u8{"gr.ht."});
var request: [1024]u8 = undefined;
const msgsize = try msg.write(&request);
 
std.debug.print("msg {}\n", .{msgsize});
std.debug.print("data {any}\n", .{request[0..msgsize]});
std.debug.print("data {s}\n", .{request[0..msgsize]});
 
const sock = try std.posix.socket(std.posix.AF.INET, std.posix.SOCK.DGRAM, 0);
try std.posix.connect(sock, &addr.any, addr.getOsSockLen());
const ocnt = try std.posix.send(sock, request[0..msgsize], 0);
std.debug.print("sent {}\n", .{ocnt});
 
var buffer: [1024]u8 = undefined;
const icnt = try std.posix.recv(sock, &buffer, 0);
std.debug.print("received {}\n", .{icnt});
std.debug.print("data {any}\n", .{buffer[0..icnt]});
std.debug.print("data {s}\n", .{buffer[0..icnt]});
 
std.debug.print("done\n", .{});
}
 
const DNS = @import("dns.zig");
 
const std = @import("std");
const log = std.log;
const Allocator = std.mem.Allocator;
const indexOfScalar = std.mem.indexOfScalar;
 
src/dns.zig added: 79, removed: 66, total 13
@@ -330,59 +330,13 @@ test "Message.Header" {
);
}
 
pub fn main() !void {
const a = std.heap.page_allocator;
std.debug.print("started\n", .{});
 
const addr: std.net.Address = .{ .in = .{ .sa = .{
.port = std.mem.nativeToBig(u16, 53),
.addr = std.mem.bytesToValue(u32, &[4]u8{ 0, 0, 0, 0 }),
} } };
 
const msg = try Message.query(a, &[1][]const u8{"gr.ht."});
var request: [1024]u8 = undefined;
const msgsize = try msg.write(&request);
 
std.debug.print("msg {}\n", .{msgsize});
std.debug.print("data {any}\n", .{request[0..msgsize]});
std.debug.print("data {s}\n", .{request[0..msgsize]});
 
const sock = try std.posix.socket(std.posix.AF.INET, std.posix.SOCK.DGRAM, 0);
try std.posix.connect(sock, &addr.any, addr.getOsSockLen());
const ocnt = try std.posix.send(sock, request[0..msgsize], 0);
std.debug.print("sent {}\n", .{ocnt});
 
var buffer: [1024]u8 = undefined;
const icnt = try std.posix.recv(sock, &buffer, 0);
std.debug.print("received {}\n", .{icnt});
std.debug.print("data {any}\n", .{buffer[0..icnt]});
std.debug.print("data {s}\n", .{buffer[0..icnt]});
 
std.debug.print("done\n", .{});
}
 
pub fn server() !void {
const sock = try std.posix.socket(std.posix.AF.INET, std.posix.SOCK.DGRAM, std.posix.SOCK.NONBLOCK);
 
const addr: std.net.Address = .{ .in = .{ .sa = .{
.port = 53,
.addr = 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});
}
 
test "grht vectors" {
const a = std.testing.allocator;
const vector = [_]u8{
122, 105, 129, 128, 0, 1, 0, 1, 0, 0, 0, 0,
2, 103, 114, 2, 104, 116, 0, 0, 1, 0, 1, 192,
12, 0, 1, 0, 1, 0, 0, 14, 16, 0, 4, 144,
126, 209, 12,
12, 0, 1, 0, 1, 0, 0, 14, 16, 0, 4, 127,
4, 20, 69,
};
const msg = try Message.fromBytes(a, &vector);
try std.testing.expectEqual(1, msg.question.?.len);
 
src/server.zig added: 79, removed: 66, total 13
@@ -0,0 +1,19 @@
pub fn server() !void {
const sock = try std.posix.socket(std.posix.AF.INET, std.posix.SOCK.DGRAM, std.posix.SOCK.NONBLOCK);
 
const addr: std.net.Address = .{ .in = .{ .sa = .{
.port = 53,
.addr = 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});
}
 
const std = @import("std");
const log = std.log;
const Allocator = std.mem.Allocator;
const indexOfScalar = std.mem.indexOfScalar;