Merge pull request #15372 from nwtgck/fix-http-client

lib/std/http.zig

@@ -275,4 +275,5 @@ test {
     _ = Client;
     _ = Method;
     _ = Status;
+    _ = @import("http/test.zig");
 }

lib/std/http/Client.zig

@@ -797,18 +797,18 @@ pub const Request = struct {
 
     /// Write `bytes` to the server. The `transfer_encoding` request header determines how data will be sent.
     pub fn write(req: *Request, bytes: []const u8) WriteError!usize {
-        switch (req.headers.transfer_encoding) {
+        switch (req.transfer_encoding) {
             .chunked => {
-                try req.connection.data.conn.writer().print("{x}\r\n", .{bytes.len});
+                try req.connection.data.buffered.writer().print("{x}\r\n", .{bytes.len});
-                try req.connection.data.conn.writeAll(bytes);
+                try req.connection.data.buffered.writeAll(bytes);
-                try req.connection.data.conn.writeAll("\r\n");
+                try req.connection.data.buffered.writeAll("\r\n");
 
                 return bytes.len;
             },
             .content_length => |*len| {
                 if (len.* < bytes.len) return error.MessageTooLong;
 
-                const amt = try req.connection.data.conn.write(bytes);
+                const amt = try req.connection.data.buffered.write(bytes);
                 len.* -= amt;
                 return amt;
             },
@@ -828,7 +828,7 @@ pub const Request = struct {
     /// Finish the body of a request. This notifies the server that you have no more data to send.
     pub fn finish(req: *Request) FinishError!void {
         switch (req.transfer_encoding) {
-            .chunked => try req.connection.data.conn.writeAll("0\r\n\r\n"),
+            .chunked => try req.connection.data.buffered.writeAll("0\r\n\r\n"),
             .content_length => |len| if (len != 0) return error.MessageNotCompleted,
             .none => {},
         }

lib/std/http/Server.zig

@@ -336,8 +336,15 @@ pub const Response = struct {
     headers: http.Headers,
     request: Request,
 
+    pub fn deinit(res: *Response) void {
+        res.server.allocator.destroy(res);
+    }
+
     /// Reset this response to its initial state. This must be called before handling a second request on the same connection.
     pub fn reset(res: *Response) void {
+        res.request.headers.deinit();
+        res.headers.deinit();
+
         switch (res.request.compression) {
             .none => {},
             .deflate => |*deflate| deflate.deinit(),
@@ -356,8 +363,6 @@ pub const Response = struct {
             if (res.request.parser.header_bytes_owned) {
                 res.request.parser.header_bytes.deinit(res.server.allocator);
             }
-
-            res.* = undefined;
         } else {
             res.request.parser.reset();
         }

lib/std/http/test.zig

@@ -0,0 +1,72 @@
+const std = @import("std");
+const expect = std.testing.expect;
+
+test "client requests server" {
+    const builtin = @import("builtin");
+
+    // This test requires spawning threads.
+    if (builtin.single_threaded) {
+        return error.SkipZigTest;
+    }
+
+    const native_endian = comptime builtin.cpu.arch.endian();
+    if (builtin.zig_backend == .stage2_llvm and native_endian == .Big) {
+        // https://github.com/ziglang/zig/issues/13782
+        return error.SkipZigTest;
+    }
+
+    if (builtin.os.tag == .wasi) return error.SkipZigTest;
+
+    const allocator = std.testing.allocator;
+
+    const max_header_size = 8192;
+    var server = std.http.Server.init(allocator, .{ .reuse_address = true });
+    defer server.deinit();
+
+    const address = try std.net.Address.parseIp("127.0.0.1", 0);
+    try server.listen(address);
+    const server_port = server.socket.listen_address.in.getPort();
+
+    const server_thread = try std.Thread.spawn(.{}, (struct {
+        fn apply(s: *std.http.Server) !void {
+            const res = try s.accept(.{ .dynamic = max_header_size });
+            defer res.deinit();
+            defer res.reset();
+            try res.wait();
+
+            const server_body: []const u8 = "message from server!\n";
+            res.transfer_encoding = .{ .content_length = server_body.len };
+            try res.headers.append("content-type", "text/plain");
+            try res.headers.append("connection", "close");
+            try res.do();
+
+            var buf: [128]u8 = undefined;
+            const n = try res.readAll(&buf);
+            try expect(std.mem.eql(u8, buf[0..n], "Hello, World!\n"));
+            _ = try res.writer().writeAll(server_body);
+            try res.finish();
+        }
+    }).apply, .{&server});
+
+    var uri_buf: [22]u8 = undefined;
+    const uri = try std.Uri.parse(try std.fmt.bufPrint(&uri_buf, "http://127.0.0.1:{d}", .{server_port}));
+    var client = std.http.Client{ .allocator = allocator };
+    defer client.deinit();
+    var client_headers = std.http.Headers{ .allocator = allocator };
+    defer client_headers.deinit();
+    var client_req = try client.request(.POST, uri, client_headers, .{});
+    defer client_req.deinit();
+
+    client_req.transfer_encoding = .{ .content_length = 14 }; // this will be checked to ensure you sent exactly 14 bytes
+    try client_req.start(); // this sends the request
+    try client_req.writeAll("Hello, ");
+    try client_req.writeAll("World!\n");
+    try client_req.finish();
+    try client_req.do(); // this waits for a response
+
+    const body = try client_req.reader().readAllAlloc(allocator, 8192 * 1024);
+    defer allocator.free(body);
+    try expect(std.mem.eql(u8, body, "message from server!\n"));
+
+    server_thread.join();
+}