path: root/src/main.zig

const is_debug = builtin.mode == .Debug;

const help =
    \\-h, --help           Display this help and exit.
    \\-r, --relay <str>    A relay message to send.
    \\-d, --dest <str>     An IPv4 or <= 4 ASCII byte string.
    \\-c, --connect <str>  A connection message to send.
    \\
;

const Option = enum { help, relay, dest, connect };
const to_option: StaticStringMap(Option) = .initComptime(.{
    .{ "-h", .help },
    .{ "--help", .help },
    .{ "-r", .relay },
    .{ "--relay", .relay },
    .{ "-d", .dest },
    .{ "--dest", .dest },
    .{ "-c", .connect },
    .{ "--connect", .connect },
});

pub fn main(init: std.process.Init) !void {
    // CLI parsing adapted from the example here
    // https://codeberg.org/ziglang/zig/pulls/30644

    const args = try init.minimal.args.toSlice(init.arena.allocator());

    if (args.len == 1) {
        std.debug.print("{s}", .{help});
        return;
    }

    var flags: struct {
        relay: ?[]const u8 = null,
        dest: ?[]const u8 = null,
        connect: ?[]const u8 = null,
    } = .{};

    {
        var i: usize = 1;
        while (i < args.len) : (i += 1) {
            if (to_option.get(args[i])) |opt| {
                switch (opt) {
                    .help => {
                        std.debug.print("{s}\n", .{help});
                        return;
                    },
                    .relay => {
                        i += 1;
                        if (i < args.len) {
                            flags.relay = args[i];
                        } else {
                            std.debug.print("-r/--relay requires a string\n", .{});
                            return error.InvalidArguments;
                        }
                    },
                    .dest => {
                        i += 1;
                        if (i < args.len) {
                            flags.dest = args[i];
                        } else {
                            std.debug.print("-d/--dest requires a string\n", .{});
                            return error.InvalidArguments;
                        }
                    },
                    .connect => {
                        i += 1;
                        if (i < args.len) {
                            flags.connect = args[i];
                        } else {
                            std.debug.print("-c/--connect requires a string\n", .{});
                            return error.InvalidArguments;
                        }
                    },
                }
            } else {
                std.debug.print("Unknown argument: {s}\n", .{args[i]});
                return error.InvalidArguments;
            }
        }
    }

    if (flags.connect != null and (flags.relay != null or flags.dest != null)) {
        std.debug.print("Incompatible arguments.\nCannot use --connect/-c with dest or relay.\n", .{});
        return error.InvalidArguments;
    }

    std.debug.print("relay: {s}\n", .{flags.relay orelse "<null>"});
    std.debug.print("dest: {s}\n", .{flags.dest orelse "<null>"});
    std.debug.print("connect: {s}\n", .{flags.connect orelse "<null>"});

    // const rand = blk: {
    //     const io_source: std.Random.IoSource = .{ .io = init.io };
    //     break :blk io_source.interface();
    // };

    // const net_interface: std.Io.net.Interface = .{ .index = 1 };
    // std.debug.print("Interface: {s}\n", .{(try net_interface.name(init.io)).toSlice()});
    const EthIpUdp = packed struct(u336) { // 42 bytes * 8 bits = 336
        // --- UDP (Last in memory, defined first for LSB->MSB) ---
        checksum: u16 = 0,
        udp_len: u16,
        dst_port: u16,
        src_port: u16,

        // --- IP ---
        dst_addr: u32,
        src_addr: u32,
        header_checksum: u16 = 0,
        protocol: u8 = 17, // udp
        ttl: u8 = 0x40,

        // fragment_offset (13 bits) + flags (3 bits) = 16 bits
        // In Big Endian, flags are the high bits of the first byte.
        // To have flags appear first in the stream, define them last here.
        fragment_offset: u13 = 0,
        flags: packed struct(u3) {
            reserved: u1 = 0,
            dont_fragment: u1 = 0,
            more_fragments: u1 = 0,
        } = .{},

        id: u16,
        total_length: u16,
        tos: u8 = undefined,

        // ip_version (4 bits) + ihl (4 bits) = 8 bits
        // To have version appear first (high nibble), define it last.
        ihl: u4 = 5,
        ip_version: u4 = 4,

        // --- Ethernet ---
        eth_type: u16 = std.os.linux.ETH.P.IP,
        src_mac: @Vector(6, u8),
        dst_mac: @Vector(6, u8) = @splat(0xff),

        fn toBytes(self: @This()) [336 / 8]u8 {
            var res: [336 / 8]u8 = undefined;
            var w: Writer = .fixed(&res);
            w.writeStruct(self, .big) catch unreachable;
            return res;
        }
    };

    const headers: EthIpUdp = .{
        .src_mac = @splat(0x0e),
        .id = 0,
        .src_addr = 0,
        .dst_addr = @bitCast([_]u8{ 255, 255, 255, 255 }),
        .src_port = undefined, // TODO: change this?
        .dst_port = 8888,

        .total_length = undefined,
        .udp_len = undefined,
    };
    std.debug.print("headers: {any}\n", .{&headers.toBytes()});

    const relay: SaprusMessage = .{
        .relay = .{
            .dest = .fromBytes(&parseDest(flags.dest)),
            .payload = flags.relay.?,
        },
    };

    var relay_bytes: [2048]u8 = undefined;
    std.debug.print("payload: {any}\n", .{relay.toBytes(&relay_bytes)});
}

fn parseDest(in: ?[]const u8) [4]u8 {
    if (in) |dest| {
        if (dest.len <= 4) {
            var res: [4]u8 = @splat(0);
            @memcpy(res[0..dest.len], dest);
            return res;
        }

        const addr = std.Io.net.Ip4Address.parse(dest, 0) catch return "FAIL".*;
        return addr.bytes;
    }
    return "zap\x00".*;
}

const builtin = @import("builtin");
const std = @import("std");
const ArrayList = std.ArrayList;
const StaticStringMap = std.StaticStringMap;

const zaprus = @import("zaprus");
const SaprusClient = zaprus.Client;
const SaprusMessage = zaprus.Message;
const RawSocketWriter = zaprus.RawSocketWriter;

const AF = std.os.linux.AF;
const SOCK = std.os.linux.SOCK;

const RawSocket = struct {
    fd: i32,
    sockaddr_ll: std.posix.sockaddr.ll,

    fn init(ifname: []const u8) RawSocket {
        const socket: i32 = @intCast(std.os.linux.socket(AF.PACKET, SOCK.RAW, 0));

        var ifr: std.posix.ifreq = std.mem.zeroInit(std.posix.ifreq, .{});
        @memcpy(ifr.ifrn.name[0..ifname.len], ifname);
        ifr.ifrn.name[ifname.len] = 0;
        try std.posix.ioctl_SIOCGIFINDEX(socket, &ifr);
        const ifindex: i32 = ifr.ifru.ivalue;

        var rval = std.posix.errno(std.os.linux.ioctl(socket, std.os.linux.SIOCGIFFLAGS, @intFromPtr(&ifr)));
        switch (rval) {
            .SUCCESS => {},
            else => {
                return error.NicError;
            },
        }
        ifr.ifru.flags.BROADCAST = true;
        ifr.ifru.flags.PROMISC = true;
        rval = std.posix.errno(std.os.linux.ioctl(socket, std.os.linux.SIOCSIFFLAGS, @intFromPtr(&ifr)));
        switch (rval) {
            .SUCCESS => {},
            else => {
                return error.NicError;
            },
        }
        std.debug.print("ifindex: {}\n", .{ifindex});
        const sockaddr_ll = std.posix.sockaddr.ll{
            .family = std.posix.AF.PACKET,
            .ifindex = ifindex,
            .protocol = std.mem.nativeToBig(u16, @as(u16, std.os.linux.ETH.P.IP)),
            .halen = 0, //not used
            .addr = .{ 0, 0, 0, 0, 0, 0, 0, 0 }, //not used
            .pkttype = 0, //not used
            .hatype = 0, //not used
        };
        _ = std.os.linux.bind(socket, @ptrCast(&sockaddr_ll), @sizeOf(@TypeOf(sockaddr_ll)));

        return .{
            .fd = socket,
            .sockaddr_ll = sockaddr_ll,
        };
    }

    fn deinit() void {}

    fn send(self: RawSocket, payload: []const u8) !void {
        const sent_bytes = std.os.linux.sendto(
            self.fd,
            payload.ptr,
            payload.len,
            0,
            @ptrCast(&self.sockaddr_ll),
            @sizeOf(@TypeOf(self.sockaddr_ll)),
        );
        std.debug.assert(sent_bytes == payload.len);
    }

    fn receive(self: RawSocket, buf: []u8) ![]u8 {
        const len = std.os.linux.recvfrom(
            self.fd,
            buf.ptr,
            buf.len,
            0, // flags
            null,
            null,
        );
        return buf[0..len];
    }
};

const Writer = std.Io.Writer;