tiny.http.Request

1pub const Request = struct {2    method: Method,3    path: []const u8,4    version: Version,5    headers: RequestHeaders,6    body: ?[]const u8,78    pub const Method = enum {9        GET,10        POST,11        PUT,12        DELETE,13        HEAD,14        OPTIONS,15        PATCH,16        CONNECT,17        TRACE,18    };1920    pub const Version = enum {21        http_1_0,22        http_1_1,23    };2425    pub const QueryIterator = struct {26        pub const Param = struct {27            key: []const u8,28            value: []const u8,29        };3031        query: ?[]const u8,32        pos: usize = 0,3334        pub fn next(self: *QueryIterator) ?Param {35            const q = self.query orelse return null;36            while (self.pos < q.len) {37                const remaining = q[self.pos..];38                const param_end = std.mem.indexOf(u8, remaining, "&") orelse remaining.len;39                const param = remaining[0..param_end];40                self.pos += param_end + 1;4142                if (param.len == 0) continue;4344                if (std.mem.indexOf(u8, param, "=")) |eq| {45                    return .{46                        .key = param[0..eq],47                        .value = if (eq + 1 < param.len) param[eq + 1 ..] else "",48                    };49                } else {50                    return .{ .key = param, .value = "" };51                }52            }53            return null;54        }5556        pub fn get(self: *QueryIterator, key: []const u8) ?[]const u8 {57            var iter = QueryIterator{ .query = self.query, .pos = 0 };58            while (iter.next()) |param| {59                if (std.mem.eql(u8, param.key, key)) {60                    return param.value;61                }62            }63            return null;64        }65    };6667    pub fn parse(scratch: RequestScratch, data: []const u8) ParseError!RequestParseResult {68        const survey = try surveyRequest(scratch, data);6970        var header_count: usize = 0;71        var pos = survey.first_line_end + 2;72        while (pos < survey.header_end) {73            const line_end = std.mem.indexOf(u8, data[pos .. survey.header_end + 2], "\r\n") orelse {74                unreachable;75            };76            const line = data[pos..][0..line_end];77            const parsed = field.parseLine(line).?;78            scratch.headers[header_count] = .{79                .name = parsed.name,80                .value = parsed.value,81            };82            header_count += 1;83            pos += line_end + 2;84        }85        std.debug.assert(header_count == survey.header_count);8687        const body: ?[]const u8 = switch (survey.body) {88            .none => null,89            .borrowed => |borrowed| data[borrowed.start..][0..borrowed.length],90            .chunked => |capacity| blk: {91                const decoded = chunked.decodeSurveyedInto(92                    scratch.body,93                    data[survey.body_start..],94                    capacity,95                ) catch unreachable;96                std.debug.assert(decoded.body.len == capacity.decoded_bytes);97                std.debug.assert(decoded.consumed == capacity.consumed);98                break :blk decoded.body;99            },100        };101102        return .{103            .request = .{104                .method = survey.method,105                .path = survey.path,106                .version = survey.version,107                .headers = .{ .entries = scratch.headers[0..header_count] },108                .body = body,109            },110            .consumed = survey.consumed,111        };112    }113114    fn parseMethod(s: []const u8) ?Method {115        const methods = .{116            .{ "GET", Method.GET },117            .{ "POST", Method.POST },118            .{ "PUT", Method.PUT },119            .{ "DELETE", Method.DELETE },120            .{ "HEAD", Method.HEAD },121            .{ "OPTIONS", Method.OPTIONS },122            .{ "PATCH", Method.PATCH },123            .{ "CONNECT", Method.CONNECT },124            .{ "TRACE", Method.TRACE },125        };126        inline for (methods) |pair| {127            if (std.mem.eql(u8, s, pair[0])) return pair[1];128        }129        return null;130    }131132    fn parseVersion(s: []const u8) ?Version {133        if (std.mem.eql(u8, s, "HTTP/1.1")) return .http_1_1;134        if (std.mem.eql(u8, s, "HTTP/1.0")) return .http_1_0;135        return null;136    }137138    fn findHeaderEnd(data: []const u8) ?usize {139        if (data.len < 4) return null;140        var i: usize = 0;141        while (i + 3 < data.len) : (i += 1) {142            if (data[i] == '\r' and data[i + 1] == '\n' and data[i + 2] == '\r' and data[i + 3] == '\n') {143                return i;144            }145        }146        return null;147    }148149    pub fn isWebSocketUpgrade(self: *const Request) bool {150        if (self.method != .GET or self.version != .http_1_1) return false;151152        const upgrade = self.headers.get("Upgrade") orelse return false;153        const connection = self.headers.get("Connection") orelse return false;154155        return containsHeaderToken(upgrade, "websocket") and156            containsHeaderToken(connection, "upgrade");157    }158159    pub fn getWebSocketKey(self: *const Request) ?[]const u8 {160        return self.headers.get("Sec-WebSocket-Key");161    }162163    pub fn pathOnly(self: *const Request) []const u8 {164        if (std.mem.indexOf(u8, self.path, "?")) |idx| {165            return self.path[0..idx];166        }167        return self.path;168    }169170    pub fn queryString(self: *const Request) ?[]const u8 {171        if (std.mem.indexOf(u8, self.path, "?")) |idx| {172            if (idx + 1 < self.path.len) {173                return self.path[idx + 1 ..];174            }175        }176        return null;177    }178179    pub fn queryParams(self: *const Request) QueryIterator {180        return QueryIterator{ .query = self.queryString() };181    }182};

1pub const Request = message.Request;