Add basic websocket support

This commit is contained in:
jaina heartles 2022-10-16 05:48:12 -07:00
parent cb2f97a28f
commit e4cbb0acc3
7 changed files with 448 additions and 3 deletions

View file

@ -111,6 +111,7 @@ pub const ApiSource = struct {
errdefer arena.deinit();
const db = try self.db_conn_pool.acquire();
errdefer db.releaseConnection();
const community = try services.communities.getByHost(db, host, arena.allocator());
return Conn{
@ -126,6 +127,7 @@ pub const ApiSource = struct {
errdefer arena.deinit();
const db = try self.db_conn_pool.acquire();
errdefer db.releaseConnection();
const community = try services.communities.getByHost(db, host, arena.allocator());
const token_info = try services.auth.verifyToken(

View file

@ -5,6 +5,8 @@ const request = @import("./request.zig");
const server = @import("./server.zig");
pub const socket = @import("./socket.zig");
pub const Method = std.http.Method;
pub const Status = std.http.Status;

View file

@ -16,6 +16,11 @@ pub const Response = struct {
return response.open(self.alloc, self.stream.writer(), headers, status);
}
pub fn upgrade(self: *Response, status: http.Status, headers: *const http.Headers) !std.net.Stream {
try response.writeRequestHeader(self.stream.writer(), headers, status);
return self.stream;
}
};
const Request = http.Request;

View file

@ -25,6 +25,12 @@ pub fn open(
};
}
pub fn writeRequestHeader(writer: anytype, headers: *const Headers, status: Status) !void {
try writeStatusLine(writer, status);
try writeHeaders(writer, headers);
try writer.writeAll("\r\n");
}
fn writeStatusLine(writer: anytype, status: Status) !void {
const status_text = status.phrase() orelse "";
try writer.print("HTTP/1.1 {} {s}\r\n", .{ @enumToInt(status), status_text });

372
src/http/socket.zig Normal file
View file

@ -0,0 +1,372 @@
const std = @import("std");
const builtin = @import("builtin");
const http = @import("./lib.zig");
const Stream = std.net.Stream;
const Opcode = enum(u4) {
continuation = 0x0,
text = 0x1,
binary = 0x2,
// 3-7 are non-control frames
close = 0x8,
ping = 0x9,
pong = 0xa,
// b-f are control frames
_,
fn isData(self: Opcode) bool {
return !self.isControl();
}
fn isControl(self: Opcode) bool {
return @enumToInt(self) & 0x8 == 0x8;
}
};
pub fn handshake(alloc: std.mem.Allocator, req: http.Request, res: *http.Response) !Socket {
const upgrade = req.headers.get("Upgrade") orelse return error.BadHandshake;
const connection = req.headers.get("Connection") orelse return error.BadHandshake;
if (std.ascii.indexOfIgnoreCase(upgrade, "websocket") == null) return error.BadHandshake;
if (std.ascii.indexOfIgnoreCase(connection, "Upgrade") == null) return error.BadHandshake;
const key_hdr = req.headers.get("Sec-WebSocket-Key") orelse return error.BadHandshake;
if (try std.base64.standard.Decoder.calcSizeForSlice(key_hdr) != 16) return error.BadHandshake;
var key: [16]u8 = undefined;
std.base64.standard.Decoder.decode(&key, key_hdr) catch return error.BadHandshake;
const version = req.headers.get("Sec-WebSocket-version") orelse return error.BadHandshake;
if (!std.mem.eql(u8, "13", version)) return error.BadHandshake;
var headers = http.Headers.init(alloc);
defer headers.deinit();
try headers.put("Upgrade", "websocket");
try headers.put("Connection", "Upgrade");
var response_key = std.mem.zeroes([60]u8);
std.mem.copy(u8, &response_key, key_hdr);
std.mem.copy(u8, response_key[key_hdr.len..], "258EAFA5-E914-47DA-95CA-C5AB0DC85B11");
const Sha1 = std.crypto.hash.Sha1;
var hash: [Sha1.digest_length]u8 = undefined;
Sha1.hash(response_key[0..], &hash, .{});
var hash_encoded: [std.base64.standard.Encoder.calcSize(Sha1.digest_length)]u8 = undefined;
_ = std.base64.standard.Encoder.encode(&hash_encoded, &hash);
try headers.put("Sec-WebSocket-Accept", &hash_encoded);
const stream = try res.upgrade(.switching_protcols, &headers);
return Socket{ .stream = stream };
}
pub const CloseReason = enum(u16) {
ok = 1000,
going_away = 1001,
protocol_error = 1002,
unsupported_frame_type = 1003,
// reserved = 1004,
// technically these codes can be explicitly provided but it's against spec
no_reason_provided = 1005,
abnormal_closure = 1006,
invalid_frame_data = 1007, // e.g. non UTF-8 data in a text type frame
policy_violation = 1008,
message_too_large = 1009,
missing_extension = 1010,
internal_server_error = 1011,
// unused on server side but included here for completeness
invalid_tls_handshake = 1015,
_,
};
const FrameInfo = struct {
is_final: bool,
rsv: u3,
opcode: Opcode,
masking_key: ?[4]u8,
len: usize,
};
fn frameReader(reader: anytype) !FrameReader(@TypeOf(reader)) {
return FrameReader(@TypeOf(reader)).open(reader);
}
fn FrameReader(comptime R: type) type {
return struct {
const Self = @This();
info: FrameInfo,
bytes_read: usize = 0,
mask_idx: u2 = 0,
underlying: R,
const Reader = std.io.Reader(*Self, anyerror, read);
fn open(r: R) !Self {
var hdr_buf: [2]u8 = undefined;
try r.readNoEof(&hdr_buf);
const is_final = hdr_buf[0] & 0b1000_0000 != 0;
const rsv = @intCast(u3, (hdr_buf[0] & 0b0111_0000) >> 4);
const opcode = @intToEnum(Opcode, (hdr_buf[0] & 0b1111));
const is_masked = hdr_buf[1] & 0b1000_0000 != 0;
const initial_len = @intCast(u7, (hdr_buf[1] & 0b0111_1111));
const len: usize = if (initial_len < 126)
initial_len
else if (initial_len == 126)
try r.readIntBig(u16)
else
try r.readIntBig(usize);
const masking_key = if (is_masked)
try r.readBytesNoEof(4)
else
null;
return Self{
.info = .{
.is_final = is_final,
.rsv = rsv,
.opcode = opcode,
.masking_key = masking_key,
.len = len,
},
.underlying = r,
};
}
fn read(self: *Self, buf: []u8) !usize {
var r = std.io.limitedReader(self.underlying, self.info.len - self.bytes_read);
const count = try r.read(buf);
if (self.info.masking_key) |mask| {
for (buf[0..count]) |*ch| {
ch.* ^= mask[self.mask_idx];
self.mask_idx +%= 1;
}
}
self.bytes_read += count;
return count;
}
fn reader(self: *Self) Reader {
return .{ .context = self };
}
fn close(self: *Self) void {
self.reader().skipBytes(@as(usize, 0) -% 1, .{}) catch {};
}
};
}
fn writeFrame(writer: anytype, header: FrameInfo, buf: []const u8) !void {
std.debug.assert(header.len == buf.len);
const initial_len: u7 = if (header.len < 126)
@intCast(u7, header.len)
else if (std.math.cast(u16, header.len)) |_|
126
else
127;
var hdr_buf = [2]u8{ 0, 0 };
hdr_buf[0] |= if (header.is_final) 0b1000_0000 else 0;
hdr_buf[0] |= @as(u8, header.rsv) << 4;
hdr_buf[0] |= @enumToInt(header.opcode);
hdr_buf[1] |= if (header.masking_key) |_| 0b1000_0000 else 0;
hdr_buf[1] |= initial_len;
try writer.writeAll(&hdr_buf);
if (initial_len == 126)
try writer.writeIntBig(u16, std.math.cast(u16, buf.len).?)
else if (initial_len == 127)
try writer.writeIntBig(usize, buf.len);
if (header.masking_key) |key| try writer.writeAll(&key);
const mask = header.masking_key orelse std.mem.zeroes([4]u8);
var mask_idx: u2 = 0;
for (buf) |ch| {
try writer.writeByte(mask[mask_idx] ^ ch);
}
}
pub const MessageReader = struct {
opcode: Opcode,
socket: *Socket,
frame: FrameReader(Socket.Reader),
pub const Reader = std.io.Reader(*MessageReader, anyerror, read);
pub fn read(self: *MessageReader, buf: []u8) !usize {
if (self.socket.closed) return error.SocketClosed;
var count: usize = 0;
while (count < buf.len) {
const c = try self.frame.read(buf);
count += c;
if (c == 0) {
self.frame.close();
if (self.frame.info.is_final) break;
self.frame = try self.socket.waitForDataFrame();
if (self.frame.info.opcode != .continuation) {
//self.socket.close();
return error.InvalidFrame;
}
}
}
return count;
}
pub fn reader(self: *MessageReader) Reader {
return .{ .context = self };
}
pub fn close(self: *MessageReader) void {
self.reader().skipBytes(@as(usize, 0) -% 1, .{}) catch {};
}
};
pub const MessageWriter = struct {
allocator: std.mem.Allocator,
socket: *Socket,
opcode: Opcode,
buf: []u8,
cursor: usize = 0,
is_first: bool = true,
pub const WriteError = Socket.WriteError;
pub const Writer = std.io.Writer(*MessageWriter, WriteError, write);
pub fn writer(self: *MessageWriter) Writer {
return .{ .context = self };
}
pub fn write(self: *MessageWriter, buf: []const u8) !usize {
if (self.socket.closed) return error.SocketClosed;
var count: usize = 0;
while (count < buf.len) {
if (self.cursor == self.buf.len) try self.flushFrame(false);
const max_write = std.math.min(self.buf.len - self.cursor, buf.len - count);
std.mem.copy(u8, self.buf[self.cursor..], buf[count .. count + max_write]);
self.cursor += max_write;
count += max_write;
}
return count;
}
pub fn close(self: *MessageWriter) void {
self.allocator.free(self.buf);
}
pub fn finish(self: *MessageWriter) !void {
if (self.socket.closed) return error.SocketClosed;
try self.flushFrame(true);
}
fn flushFrame(self: *MessageWriter, is_final: bool) !void {
if (self.socket.closed) return error.SocketClosed;
const opcode = if (self.is_first) self.opcode else .continuation;
self.is_first = false;
const header = FrameInfo{
.is_final = is_final,
.rsv = 0,
.opcode = opcode,
.masking_key = null, // TODO: use a key on client-side
.len = self.cursor,
};
std.log.debug("sending frame with size {}", .{header.len});
try writeFrame(self.socket.writer(), header, self.buf[0..self.cursor]);
self.cursor = 0;
}
};
pub const Socket = struct {
stream: Stream,
closed: bool = false,
const ReadError = Stream.ReadError || error{SocketClosed};
const WriteError = Stream.WriteError || error{SocketClosed};
const Reader = std.io.Reader(*Socket, ReadError, read);
const Writer = std.io.Writer(*Socket, WriteError, write);
fn writer(self: *Socket) Writer {
return .{ .context = self };
}
fn reader(self: *Socket) Reader {
return .{ .context = self };
}
fn read(self: *Socket, buf: []u8) !usize {
if (self.closed) return error.SocketClosed;
return self.stream.read(buf) catch |err| {
self.closed = true;
return err;
};
}
fn write(self: *Socket, buf: []const u8) !usize {
if (self.closed) return error.SocketClosed;
return self.stream.write(buf) catch |err| {
self.closed = true;
return err;
};
}
pub fn accept(self: *Socket) !MessageReader {
if (self.closed) return error.SocketClosed;
const frame = try self.waitForDataFrame();
return MessageReader{ .opcode = frame.info.opcode, .socket = self, .frame = frame };
}
pub const MessageOptions = struct {
buf_size: usize = 512,
};
pub fn openMessage(self: *Socket, opcode: Opcode, alloc: std.mem.Allocator, options: MessageOptions) !MessageWriter {
if (self.closed) return error.SocketClosed;
var buf = try alloc.alloc(u8, options.buf_size);
return MessageWriter{ .socket = self, .allocator = alloc, .buf = buf, .opcode = opcode };
}
fn openFrame(self: *Socket) !FrameReader(Reader) {
std.log.debug("waiting for frame header", .{});
const frame = try frameReader(self.reader());
std.log.debug("Received frame of type {any}, size {}", .{ frame.info.opcode, frame.info.len });
return frame;
}
fn waitForDataFrame(self: *Socket) !FrameReader(Reader) {
while (true) {
var frame = try frameReader(self.reader());
if (frame.info.opcode.isData()) return frame;
// TODO: handle control frames
frame.close();
}
}
};
fn pipe(writer: anytype, reader: anytype) !usize {
var count: usize = 0;
var buf: [64]u8 = undefined;
while (true) {
const c = try reader.read(&buf);
if (c == 0) break;
if (try writer.write(buf[0..c]) != c) return error.EndOfStream;
count += c;
}
return count;
}

View file

@ -12,16 +12,24 @@ pub const communities = @import("./controllers/communities.zig");
pub const invites = @import("./controllers/invites.zig");
pub const users = @import("./controllers/users.zig");
pub const notes = @import("./controllers/notes.zig");
pub const streaming = @import("./controllers/streaming.zig");
pub fn routeRequest(api_source: anytype, req: http.Request, res: *http.Response, alloc: std.mem.Allocator) void {
// TODO: hashmaps?
var response = Response{ .headers = http.Headers.init(alloc), .res = res };
defer response.headers.deinit();
const found = routeRequestInternal(api_source, req, &response, alloc);
if (!found) response.status(.not_found) catch {};
}
fn routeRequestInternal(api_source: anytype, req: http.Request, res: *Response, alloc: std.mem.Allocator) bool {
inline for (routes) |route| {
if (Context(route).matchAndHandle(api_source, req, &response, alloc)) return;
if (Context(route).matchAndHandle(api_source, req, res, alloc)) return true;
}
response.status(.not_found) catch {};
return false;
}
const routes = .{
@ -33,6 +41,7 @@ const routes = .{
users.create,
notes.create,
notes.get,
streaming.streaming,
};
pub fn Context(comptime Route: type) type {
@ -49,6 +58,8 @@ pub fn Context(comptime Route: type) type {
// leave it as a simple string instead of void
pub const Query = if (@hasDecl(Route, "Query")) Route.Query else void;
base_request: http.Request,
allocator: std.mem.Allocator,
method: http.Method,
@ -90,6 +101,7 @@ pub fn Context(comptime Route: type) type {
var self = Self{
.allocator = alloc,
.base_request = req,
.method = req.method,
.uri = req.uri,
@ -155,7 +167,7 @@ pub fn Context(comptime Route: type) type {
Route.handler(self, response, api_conn) catch |err| switch (err) {
else => {
std.log.err("{}", .{err});
response.err(.internal_server_error, "", {}) catch {};
if (!response.opened) response.err(.internal_server_error, "", {}) catch {};
},
};
}
@ -183,6 +195,7 @@ pub const Response = struct {
res: *http.Response,
opened: bool = false,
/// Write a response with no body, only a given status
pub fn status(self: *Self, status_code: http.Status) !void {
std.debug.assert(!self.opened);
self.opened = true;
@ -192,6 +205,7 @@ pub const Response = struct {
try stream.finish();
}
/// Write a request body as json
pub fn json(self: *Self, status_code: http.Status, response_body: anytype) !void {
std.debug.assert(!self.opened);
self.opened = true;
@ -207,12 +221,20 @@ pub const Response = struct {
try stream.finish();
}
/// Prints the given error as json
pub fn err(self: *Self, status_code: http.Status, message: []const u8, details: anytype) !void {
return self.json(status_code, .{
.message = message,
.details = details,
});
}
/// Signals that the HTTP connection should be hijacked without writing a
/// response beforehand.
pub fn hijack(self: *Self) *http.Response {
self.opened = true;
return self.res;
}
};
const json_options = if (builtin.mode == .Debug)

View file

@ -0,0 +1,36 @@
const http = @import("http");
const std = @import("std");
pub const streaming = struct {
pub const method = .GET;
pub const path = "/streaming";
pub fn handler(req: anytype, response: anytype, _: anytype) !void {
var iter = req.headers.iterator();
std.log.debug("--Headers--", .{});
while (iter.next()) |pair| {
std.log.debug("{s}: {s}", .{ pair.key_ptr.*, pair.value_ptr.* });
}
const res = response.hijack();
var socket = try http.socket.handshake(req.allocator, req.base_request, res);
while (true) {
var message = try socket.accept();
defer message.close();
std.log.debug("Message received", .{});
const reader = message.reader();
const msg = try reader.readAllAlloc(req.allocator, 1 << 63);
defer req.allocator.free(msg);
var response_msg = try socket.openMessage(.text, req.allocator, .{});
defer response_msg.close();
try response_msg.writer().writeAll(msg);
try response_msg.finish();
std.log.debug("{s}", .{msg});
}
}
};