my main.zig
const std = @import("std");
const Io = std.Io;
const crypto = std.crypto;
const Parser = @import("bencode.zig").Parser;
const Server = @import("tracker_client.zig").Server;
pub fn main(init: std.process.Init) !void {
var debug_allocator = std.heap.DebugAllocator(.{ .thread_safe = true }).init;
defer _ = debug_allocator.deinit();
const allocator = debug_allocator.allocator();
const io = init.io;
const file = try std.Io.Dir.openFile(.cwd(), io, "aapun.txt.torrent", .{});
defer file.close(io);
var server = Server.init("127.0.0.1", allocator, io);
defer server.deinit();
try server.listen_and_accept_connections();
}
and my server module
const std = @import("std");
const c = @import("c");
const Cancelable = std.Io.Cancelable;
const ClientError = error{
Cancelable,
OutOfMemory,
};
var stop_server = std.atomic.Value(bool).init(false);
fn sigint_handler(_: c_int) callconv(.c) void {
stop_server.store(true, .seq_cst);
}
pub const Server = struct {
allocator: std.mem.Allocator,
io: std.Io,
server_url: []const u8,
server_port: u16 = 8990,
pub fn init(server_url: []const u8, allocator: std.mem.Allocator, io: std.Io) Server {
return .{
.allocator = allocator,
.io = io,
.server_url = server_url,
};
}
pub fn deinit(self: *Server) void {
std.log.info("\nServer Stopped!\n", .{});
_ = self;
}
pub fn listen_and_accept_connections(self: *Server) !void {
_ = c.signal(c.SIGINT, sigint_handler);
const ipaddr = try std.Io.net.IpAddress.parse(self.server_url, self.server_port);
var server = try ipaddr.listen(self.io, .{ .reuse_address = true });
var group = std.Io.Group.init;
defer {
std.debug.print("Waiting for group...\n", .{});
group.await(self.io) catch |err| {
std.debug.print("Group await err: {}\n", .{err});
};
std.debug.print("Group finished\n", .{});
}
while (!stop_server.load(.seq_cst)) {
std.debug.print("stop_server = {}\n", .{stop_server.load(.seq_cst)});
const client_stream = server.accept(self.io) catch |err| {
std.debug.print("accept error = {}, stop_server = {}\n", .{ err, stop_server.load(.seq_cst) });
if (stop_server.load(.seq_cst))
break;
return err;
};
std.debug.print("are we here stop_server = {}\n", .{stop_server.load(.seq_cst)});
group.async(self.io, handle_client, .{ self, client_stream });
}
}
fn handle_client(self: *Server, stream: std.Io.net.Stream) std.Io.Cancelable!void {
defer stream.close(self.io);
const client_addr = std.fmt.allocPrint(self.allocator, "{s}:{d}", .{ stream.socket.address.ip4.bytes, stream.socket.address.ip4.port }) catch |err| {
std.debug.print("Client Handle AllocPrint Error: {any}", .{err});
return error.Canceled;
};
defer self.allocator.free(client_addr);
std.debug.print("New Client Added: {s}\n", .{client_addr});
defer std.debug.print("Client Exited: {s}\n", .{client_addr});
}
};
Here I am trying to have proper deinit function running when we do Server.deinit() but I don’t know how can i do this I also tried SIGINT handler, idk how would i make it proper working
Please Please, explain it to me where i am wrong or how can i resolve this one