239 lines
8.8 KiB
Zig
239 lines
8.8 KiB
Zig
const std = @import("std");
|
|
const http = @import("apple_pie");
|
|
const hzzp = @import("hzzp");
|
|
|
|
const images_dir_path = "./images";
|
|
|
|
pub fn main() anyerror!void {
|
|
std.log.info("welcome to webscale", .{});
|
|
|
|
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
|
|
defer _ = gpa.deinit();
|
|
|
|
// TODO: configurable addr via env var
|
|
const bind_addr = try std.net.Address.parseIp("0.0.0.0", 8080);
|
|
std.log.info("serving on {}", .{bind_addr});
|
|
|
|
// TODO: configurable path via env var
|
|
try std.fs.cwd().makePath(images_dir_path);
|
|
|
|
try http.listenAndServe(
|
|
&gpa.allocator,
|
|
bind_addr,
|
|
comptime http.router.router(&[_]http.router.Route{
|
|
http.router.get("/", index),
|
|
http.router.post("/api/upload", uploadFile),
|
|
http.router.get("/i/:filename", fetchFile),
|
|
}),
|
|
);
|
|
}
|
|
|
|
fn index(response: *http.Response, request: http.Request) !void {
|
|
try response.writer().writeAll("Hello Zig!");
|
|
}
|
|
|
|
fn generateImageId(buffer: []u8) []const u8 {
|
|
var i: usize = 0;
|
|
|
|
const seed = @truncate(u64, @bitCast(u128, std.time.nanoTimestamp()));
|
|
var r = std.rand.DefaultPrng.init(seed);
|
|
|
|
while (i < 16) : (i += 1) {
|
|
// random ascii lowercase char
|
|
var idx = @intCast(u8, r.random.uintLessThan(u5, 24));
|
|
var letter = @as(u8, 97) + idx;
|
|
buffer[i] = letter;
|
|
}
|
|
|
|
return buffer[0..i];
|
|
}
|
|
|
|
const StreamT = std.io.FixedBufferStream([]const u8);
|
|
|
|
const ContentDisposition = struct {
|
|
name: []const u8,
|
|
filename: []const u8,
|
|
};
|
|
|
|
const Part = struct {
|
|
disposition: ContentDisposition,
|
|
content_type: []const u8,
|
|
};
|
|
|
|
const Multipart = struct {
|
|
stream: StreamT,
|
|
boundary: []const u8,
|
|
cursor: usize = 0,
|
|
|
|
const Self = @This();
|
|
|
|
// TODO: move boundary_buffer to allocator
|
|
pub fn init(body: []const u8, content_type: []const u8, boundary_buffer: []u8) !Multipart {
|
|
// parse content_type into what we want (the boundary)
|
|
var it = std.mem.split(content_type, ";");
|
|
const should_be_multipart = it.next() orelse return error.MissingContentType;
|
|
std.log.debug("should be multipart: {s}", .{should_be_multipart});
|
|
if (!std.mem.eql(u8, should_be_multipart, "multipart/form-data"))
|
|
return error.InvalidContentType;
|
|
|
|
const should_be_boundary = it.next() orelse return error.MissingBoundary;
|
|
std.log.debug("should be boundary: {s} {d}", .{ should_be_boundary, should_be_boundary.len });
|
|
if (!std.mem.startsWith(u8, should_be_boundary, " boundary="))
|
|
return error.InvalidBoundary;
|
|
|
|
var boundary_it = std.mem.split(should_be_boundary, "=");
|
|
_ = boundary_it.next();
|
|
const boundary_value = boundary_it.next() orelse return error.InvalidBoundary;
|
|
std.log.debug("boundary value: {s} {d}", .{ boundary_value, boundary_value.len });
|
|
|
|
const actual_boundary_value = try std.fmt.bufPrint(boundary_buffer, "--{s}", .{boundary_value});
|
|
std.log.debug("actual boundary value: {s} {d}", .{ actual_boundary_value, actual_boundary_value.len });
|
|
|
|
return Self{
|
|
.stream = StreamT{ .buffer = body, .pos = 0 },
|
|
.boundary = actual_boundary_value,
|
|
};
|
|
}
|
|
|
|
pub fn next(self: *Self, hzzp_buffer: []u8) !?Part {
|
|
var reader = self.stream.reader();
|
|
// first self.boundary.len+2 bytes MUST be boundary + \r + \n
|
|
var boundary_buffer: [512]u8 = undefined;
|
|
const maybe_boundary_raw = (try reader.readUntilDelimiterOrEof(&boundary_buffer, '\n')).?;
|
|
|
|
const maybe_boundary_strip1 = std.mem.trimRight(u8, maybe_boundary_raw, "\n");
|
|
const maybe_boundary_strip2 = std.mem.trimRight(u8, maybe_boundary_strip1, "\r");
|
|
if (!std.mem.eql(u8, maybe_boundary_strip2, self.boundary)) {
|
|
std.log.err("expected '{s}' {}, got '{s}' {}", .{ self.boundary, self.boundary.len, maybe_boundary_strip2, maybe_boundary_strip2.len });
|
|
return error.InvalidBoundaryBody;
|
|
}
|
|
std.log.debug("got successful boundary {s}", .{maybe_boundary_strip2});
|
|
|
|
// from there ownwards, its just http!
|
|
var parser = hzzp.parser.request.create(hzzp_buffer, reader);
|
|
|
|
// This is a hack so that it doesnt try to parse an http header.
|
|
parser.state = .header;
|
|
|
|
var content_disposition: ?ContentDisposition = null;
|
|
var content_type: ?[]const u8 = null;
|
|
|
|
std.log.debug("next bytes: {any}", .{self.stream.buffer[self.stream.pos..(self.stream.pos + 50)]});
|
|
|
|
while (try parser.next()) |event| {
|
|
std.log.debug("got event: {}", .{event});
|
|
switch (event) {
|
|
.status => unreachable,
|
|
.end => break,
|
|
.head_done => {},
|
|
.header => |header| {
|
|
// TODO lowercase header name
|
|
if (std.mem.eql(u8, header.name, "Content-Disposition")) {
|
|
// parse disposition
|
|
var disposition_it = std.mem.split(header.value, ";");
|
|
_ = disposition_it.next();
|
|
|
|
var dispo_name: []const u8 = undefined;
|
|
var dispo_filename: []const u8 = undefined;
|
|
|
|
while (disposition_it.next()) |disposition_part_raw| {
|
|
const disposition_part = std.mem.trim(u8, disposition_part_raw, " ");
|
|
|
|
if (std.mem.eql(u8, disposition_part, "form-data")) continue;
|
|
|
|
// we have an A=B thing
|
|
var single_part_it = std.mem.split(disposition_part, "=");
|
|
|
|
const inner_part_name = single_part_it.next().?;
|
|
const inner_part_value_quoted = single_part_it.next().?;
|
|
|
|
const inner_part_value = std.mem.trim(u8, inner_part_value_quoted, "\"");
|
|
|
|
if (std.mem.eql(u8, inner_part_name, "name")) dispo_name = inner_part_value;
|
|
if (std.mem.eql(u8, inner_part_name, "filename")) dispo_filename = inner_part_value;
|
|
}
|
|
|
|
content_disposition = ContentDisposition{
|
|
.name = dispo_name,
|
|
.filename = dispo_filename,
|
|
};
|
|
std.log.debug("got content disposition for part! {}", .{content_disposition});
|
|
} else if (std.mem.eql(u8, header.name, "Content-Type")) {
|
|
content_type = header.value;
|
|
std.log.debug("got content type for part! {s}", .{content_type});
|
|
}
|
|
},
|
|
else => {
|
|
std.log.err("unexpected event: {}", .{event});
|
|
@panic("shit");
|
|
},
|
|
}
|
|
}
|
|
|
|
return Part{
|
|
.disposition = content_disposition.?,
|
|
.content_type = content_type.?,
|
|
};
|
|
}
|
|
};
|
|
|
|
fn uploadFile(response: *http.Response, request: http.Request) !void {
|
|
std.log.info("upload! got {d} bytes", .{request.body.len});
|
|
|
|
// find content-type header
|
|
var it = request.iterator();
|
|
var content_type: ?[]const u8 = null;
|
|
while (it.next()) |header| {
|
|
if (std.mem.eql(u8, header.key, "Content-Type")) {
|
|
content_type = header.value;
|
|
}
|
|
}
|
|
|
|
if (content_type == null) return error.InvalidContentType;
|
|
|
|
// parse multipart data
|
|
var boundary_buffer: [512]u8 = undefined;
|
|
var multipart = try Multipart.init(request.body, content_type.?, &boundary_buffer);
|
|
var hzzp_buffer: [1024]u8 = undefined;
|
|
|
|
while (try multipart.next(&hzzp_buffer)) |part| {
|
|
std.log.info("part: {}", .{part});
|
|
}
|
|
|
|
var image_id_buffer: [256]u8 = undefined;
|
|
const image_id = generateImageId(&image_id_buffer);
|
|
|
|
var image_path_buffer: [512]u8 = undefined;
|
|
const image_path = try std.fmt.bufPrint(
|
|
&image_path_buffer,
|
|
"{s}/{s}.jpg",
|
|
.{ images_dir_path, image_id },
|
|
);
|
|
|
|
const image_file = try std.fs.cwd().createFile(image_path, .{});
|
|
try image_file.writer().writeAll(request.body);
|
|
|
|
try response.writer().writeAll(image_path);
|
|
}
|
|
|
|
fn fetchFile(response: *http.Response, request: http.Request, filename: []const u8) !void {
|
|
std.log.info("got name: {s}", .{filename});
|
|
var image_path_buffer: [512]u8 = undefined;
|
|
|
|
const images_dir = try std.fs.cwd().openDir(images_dir_path, .{});
|
|
const image_path = try std.fmt.bufPrint(
|
|
&image_path_buffer,
|
|
"{s}/{s}",
|
|
.{ images_dir_path, filename },
|
|
);
|
|
|
|
// TODO return 404 on error
|
|
const image_file = try std.fs.cwd().openFile(image_path, .{ .read = false });
|
|
while (true) {
|
|
var file_write_buffer: [1024]u8 = undefined;
|
|
const bytes_read = try image_file.read(&file_write_buffer);
|
|
if (bytes_read == 0) return;
|
|
try response.writer().writeAll(&file_write_buffer);
|
|
}
|
|
}
|