core: dupe strings from lua for config table

src/irc.zig

···
         name: ?[]const u8 = null,
         tls: bool = true,
         lua_table: i32,
+
+        /// Creates a copy of this config. Nullable strings are not copied
+        pub fn copy(self: Config, gpa: std.mem.Allocator) Allocator.Error!Config {
+            return .{
+                .user = try gpa.dupe(u8, self.user),
+                .nick = try gpa.dupe(u8, self.nick),
+                .password = try gpa.dupe(u8, self.password),
+                .real_name = try gpa.dupe(u8, self.real_name),
+                .server = try gpa.dupe(u8, self.server),
+                .port = self.port,
+                .lua_table = self.lua_table,
+            };
+        }
+
+        pub fn deinit(self: Config, gpa: std.mem.Allocator) void {
+            gpa.free(self.user);
+            gpa.free(self.nick);
+            gpa.free(self.password);
+            gpa.free(self.real_name);
+            gpa.free(self.server);
+            if (self.network_id) |v| gpa.free(v);
+            if (self.network_nick) |v| gpa.free(v);
+            if (self.name) |v| gpa.free(v);
+        }
     };
 
     pub const Capabilities = struct {
···
             thread.join();
             self.thread = null;
         }
-        // id gets allocated in the main thread. We need to deallocate it here if
-        // we have one
-        if (self.config.network_id) |id| self.alloc.free(id);
-        if (self.config.name) |name| self.alloc.free(name);
 
-        if (self.config.network_nick) |nick| self.alloc.free(nick);
+        self.config.deinit(self.alloc);
 
         for (self.channels.items) |channel| {
             channel.deinit(self.alloc);
···
                             }
                         }
 
-                        var cfg = client.config;
-                        cfg.network_id = try self.alloc.dupe(u8, id);
+                        var cfg = try client.config.copy(self.alloc);
+                        cfg.network_id = try self.app.alloc.dupe(u8, id);
 
                         var attr_iter = std.mem.splitScalar(u8, attr, ';');
                         while (attr_iter.next()) |kv| {

src/lua.zig

···
             else => lua.raiseErrorStr("expected a boolean for field 'tls'", .{}),
         };
 
-        // Ref the config table so it doesn't get garbage collected
-        _ = lua.ref(registry_index) catch lua.raiseErrorStr("couldn't ref config table", .{}); // []
-
         Client.initTable(lua); // [table]
         const table_ref = lua.ref(registry_index) catch {
             lua.raiseErrorStr("couldn't ref client table", .{});
         };
 
+        const app = getApp(lua);
+        const gpa = app.alloc;
+
         const cfg: irc.Client.Config = .{
-            .server = server,
-            .user = user,
-            .nick = nick,
-            .password = password,
-            .real_name = real_name,
+            .server = gpa.dupe(u8, server) catch lua.raiseErrorStr("out of memory", .{}),
+            .user = gpa.dupe(u8, user) catch lua.raiseErrorStr("out of memory", .{}),
+            .nick = gpa.dupe(u8, nick) catch lua.raiseErrorStr("out of memory", .{}),
+            .password = gpa.dupe(u8, password) catch lua.raiseErrorStr("out of memory", .{}),
+            .real_name = gpa.dupe(u8, real_name) catch lua.raiseErrorStr("out of memory", .{}),
             .tls = tls,
             .lua_table = table_ref,
             .port = port,
         };
 
-        const app = getApp(lua);
         app.connect(cfg) catch {
             lua.raiseErrorStr("couldn't connect", .{});
         };