tiny.http.Response

1pub const Response = struct {2    status: u16,3    status_text: []const u8,4    headers: Headers,5    body: ?[]const u8,6    body_release: ?BodyRelease,7    head_storage: []u8,89    const BodyRelease = struct {10        context: *anyopaque,11        callback: *const fn (*anyopaque, []const u8) void,12        body: []const u8,13    };1415    pub fn init(scratch: Scratch) Response {16        return .{17            .status = 200,18            .status_text = "OK",19            .headers = .{ .entries = scratch.headers, .length = 0 },20            .body = null,21            .body_release = null,22            .head_storage = scratch.head,23        };24    }2526    pub fn deinit(self: *Response) void {27        if (self.body_release) |release| {28            release.callback(release.context, release.body);29        }30        self.body = null;31        self.body_release = null;32    }3334    pub fn setBodyWithRelease(35        self: *Response,36        body: []const u8,37        context: anytype,38        comptime release_body: anytype,39    ) void {40        const Context = @TypeOf(context);41        const info = @typeInfo(Context);42        if (info != .pointer or info.pointer.size != .one) {43            @compileError("response body release context must be a single-item pointer");44        }45        const Erased = struct {46            fn release(erased: *anyopaque, bytes: []const u8) void {47                const typed: Context = @ptrCast(@alignCast(erased));48                release_body(typed, bytes);49            }50        };51        self.deinit();52        self.body = body;53        self.body_release = .{54            .context = @ptrCast(@constCast(context)),55            .callback = Erased.release,56            .body = body,57        };58    }5960    pub fn setHeader(self: *Response, name: []const u8, value: []const u8) Error!void {61        try self.headers.set(name, value);62    }6364    pub fn serialize(self: *const Response) Error!Serialized {65        return self.serializeWithOptions(.{});66    }6768    pub fn serializeForMethod(self: *const Response, method: Request.Method) Error!Serialized {69        return self.serializeWithOptions(.{ .method = method });70    }7172    pub fn switchingProtocols(scratch: Scratch, accept_key: []const u8) Error!Response {73        if (scratch.headers.len < 3) return error.HeaderCapacityExceeded;74        var response = Response.init(scratch);75        response.status = 101;76        response.status_text = "Switching Protocols";77        try response.setHeader("Upgrade", "websocket");78        try response.setHeader("Connection", "Upgrade");79        try response.setHeader("Sec-WebSocket-Accept", accept_key);80        return response;81    }8283    fn serializeWithOptions(self: *const Response, options: SerializeOptions) Error!Serialized {84        const head_length = try self.serializedHeadLength();85        if (head_length > self.head_storage.len) return error.HeadCapacityExceeded;8687        var fixed = std.Io.Writer.fixed(self.head_storage[0..head_length]);88        const writer = &fixed;89        writer.print("HTTP/1.1 {d} {s}\r\n", .{ self.status, self.status_text }) catch unreachable;90        for (self.headers.entries[0..self.headers.length]) |entry| {91            if (!self.shouldWriteHeader(entry.name)) continue;92            writer.print("{s}: {s}\r\n", .{ entry.name, entry.value }) catch unreachable;93        }94        if (self.body) |body| {95            if (self.shouldWriteContentLength() and !self.headers.contains("Content-Length")) {96                writer.print("Content-Length: {d}\r\n", .{body.len}) catch unreachable;97            }98        }99        writer.writeAll("\r\n") catch unreachable;100        std.debug.assert(writer.buffered().len == head_length);101102        return .{103            .head = writer.buffered(),104            .body = if (self.shouldWriteBody(options)) self.body else null,105        };106    }107108    fn serializedHeadLength(self: *const Response) Error!usize {109        var length: usize = 0;110        length = try addLength(length, "HTTP/1.1 ".len);111        length = try addLength(length, decimalLength(self.status));112        length = try addLength(length, " ".len);113        length = try addLength(length, self.status_text.len);114        length = try addLength(length, "\r\n".len);115        for (self.headers.entries[0..self.headers.length]) |entry| {116            if (!self.shouldWriteHeader(entry.name)) continue;117            length = try addLength(length, entry.name.len);118            length = try addLength(length, ": ".len);119            length = try addLength(length, entry.value.len);120            length = try addLength(length, "\r\n".len);121        }122        if (self.body) |body| {123            if (self.shouldWriteContentLength() and !self.headers.contains("Content-Length")) {124                length = try addLength(length, "Content-Length: ".len);125                length = try addLength(length, decimalLength(body.len));126                length = try addLength(length, "\r\n".len);127            }128        }129        return addLength(length, "\r\n".len);130    }131132    fn shouldWriteHeader(self: *const Response, name: []const u8) bool {133        if (std.ascii.eqlIgnoreCase(name, "Transfer-Encoding")) {134            return self.statusAllowsBody();135        }136        if (std.ascii.eqlIgnoreCase(name, "Content-Length")) {137            return self.statusAllowsContentLength();138        }139        return true;140    }141142    fn shouldWriteContentLength(self: *const Response) bool {143        return self.statusAllowsContentLength();144    }145146    fn shouldWriteBody(self: *const Response, options: SerializeOptions) bool {147        if (self.body == null) return false;148        if (!self.statusAllowsBody()) return false;149        if (options.method) |method| {150            if (method == .HEAD) return false;151        }152        return true;153    }154155    fn statusAllowsBody(self: *const Response) bool {156        if (self.status >= 100 and self.status < 200) return false;157        return self.status != 204 and self.status != 304;158    }159160    fn statusAllowsContentLength(self: *const Response) bool {161        if (self.status >= 100 and self.status < 200) return false;162        return self.status != 204;163    }164};

1pub const Response = response.Response;