Use zig allocator for libcurl

src/network/Runtime.zig

@@ -51,8 +51,120 @@ wakeup_pipe: [2]posix.fd_t = .{ -1, -1 },
 
 shutdown: std.atomic.Value(bool) = .init(false),
 
-fn globalInit() void {
-    libcurl.curl_global_init(.{ .ssl = true }) catch |err| {
+const ZigToCurlAllocator = struct {
+    // C11 requires malloc to return memory aligned to max_align_t (16 bytes on x86_64).
+    // We match this guarantee since libcurl expects malloc-compatible alignment.
+    const alignment = 16;
+
+    const Block = extern struct {
+        size: usize = 0,
+        _padding: [alignment - @sizeOf(usize)]u8 = .{0} ** (alignment - @sizeOf(usize)),
+
+        inline fn fullsize(bytes: usize) usize {
+            return alignment + bytes;
+        }
+
+        inline fn fromPtr(ptr: *anyopaque) *Block {
+            const raw: [*]u8 = @ptrCast(ptr);
+            return @ptrCast(@alignCast(raw - @sizeOf(Block)));
+        }
+
+        inline fn data(self: *Block) [*]u8 {
+            const ptr: [*]u8 = @ptrCast(self);
+            return ptr + @sizeOf(Block);
+        }
+
+        inline fn slice(self: *Block) []align(alignment) u8 {
+            const base: [*]align(alignment) u8 = @ptrCast(@alignCast(self));
+            return base[0 .. alignment + self.size];
+        }
+    };
+
+    comptime {
+        std.debug.assert(@sizeOf(Block) == alignment);
+    }
+
+    var instance: ?ZigToCurlAllocator = null;
+
+    allocator: Allocator,
+
+    pub fn init(allocator: Allocator) void {
+        lp.assert(instance == null, "Initialization of curl must happen only once", .{});
+        instance = .{ .allocator = allocator };
+    }
+
+    pub fn interface() libcurl.CurlAllocator {
+        return .{
+            .free = free,
+            .strdup = strdup,
+            .malloc = malloc,
+            .calloc = calloc,
+            .realloc = realloc,
+        };
+    }
+
+    fn _allocBlock(size: usize) ?*Block {
+        const slice = instance.?.allocator.alignedAlloc(u8, .fromByteUnits(alignment), Block.fullsize(size)) catch return null;
+        const block: *Block = @ptrCast(@alignCast(slice.ptr));
+        block.size = size;
+        return block;
+    }
+
+    fn _freeBlock(header: *Block) void {
+        instance.?.allocator.free(header.slice());
+    }
+
+    fn malloc(size: usize) ?*anyopaque {
+        const block = _allocBlock(size) orelse return null;
+        return @ptrCast(block.data());
+    }
+
+    fn calloc(nmemb: usize, size: usize) ?*anyopaque {
+        const total = nmemb * size;
+        const block = _allocBlock(total) orelse return null;
+        const ptr = block.data();
+        @memset(ptr[0..total], 0); // for historical reasons, calloc zeroes memory, but malloc does not.
+        return @ptrCast(ptr);
+    }
+
+    fn realloc(ptr: ?*anyopaque, size: usize) ?*anyopaque {
+        const p = ptr orelse return malloc(size);
+        const block = Block.fromPtr(p);
+
+        const old_size = block.size;
+        if (size == old_size) return ptr;
+
+        if (instance.?.allocator.resize(block.slice(), alignment + size)) {
+            block.size = size;
+            return ptr;
+        }
+
+        const copy_size = @min(old_size, size);
+        const new_block = _allocBlock(size) orelse return null;
+        @memcpy(new_block.data()[0..copy_size], block.data()[0..copy_size]);
+        _freeBlock(block);
+        return @ptrCast(new_block.data());
+    }
+
+    fn free(ptr: ?*anyopaque) void {
+        const p = ptr orelse return;
+        _freeBlock(Block.fromPtr(p));
+    }
+
+    fn strdup(str: [*:0]const u8) ?[*:0]u8 {
+        const len = std.mem.len(str);
+        const header = _allocBlock(len + 1) orelse return null;
+        const ptr = header.data();
+        @memcpy(ptr[0..len], str[0..len]);
+        ptr[len] = 0;
+        return ptr[0..len :0];
+    }
+};
+
+fn globalInit(allocator: Allocator) void {
+    ZigToCurlAllocator.init(allocator);
+
+    libcurl.curl_global_init(.{ .ssl = true }, ZigToCurlAllocator.interface()) catch |err| {
         lp.assert(false, "curl global init", .{ .err = err });
     };
 }
@@ -62,7 +174,7 @@ fn globalDeinit() void {
 }
 
 pub fn init(allocator: Allocator, config: *const Config) !Runtime {
-    globalInit();
+    globalInit(allocator);
     errdefer globalDeinit();
 
     const pipe = try posix.pipe2(.{ .NONBLOCK = true, .CLOEXEC = true });