From 5a0736cf2a9f8a50590e188d3392a7020bc6e1ae Mon Sep 17 00:00:00 2001 From: Luna Date: Sat, 10 Apr 2021 15:12:17 -0300 Subject: [PATCH 1/5] multipart: create full boundary value --- src/main.zig | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/src/main.zig b/src/main.zig index ec281c0..7a05277 100644 --- a/src/main.zig +++ b/src/main.zig @@ -67,24 +67,31 @@ const Multipart = struct { const Self = @This(); - pub fn init(body: []const u8, content_type: []const u8) !Multipart { + // 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 = boundary_value, + .boundary = actual_boundary_value, }; } From aed35035f5b4a4878b06ae344637ef287148232f Mon Sep 17 00:00:00 2001 From: Luna Date: Sat, 10 Apr 2021 15:12:38 -0300 Subject: [PATCH 2/5] multipart: parse content disposition --- src/main.zig | 32 +++++++++++++++++++++++++++----- 1 file changed, 27 insertions(+), 5 deletions(-) diff --git a/src/main.zig b/src/main.zig index 7a05277..a3cc50a 100644 --- a/src/main.zig +++ b/src/main.zig @@ -99,14 +99,15 @@ const Multipart = struct { 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, '\r')).?; + 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, maybe_boundary_strip2 }); + 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); @@ -117,9 +118,14 @@ const Multipart = struct { 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")) { @@ -132,18 +138,33 @@ const Multipart = struct { 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 = single_part_it.next().?; + + 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}); } }, - .end => break, - else => @panic("shit"), + else => { + std.log.err("unexpected event: {}", .{event}); + @panic("shit"); + }, } } @@ -169,7 +190,8 @@ fn uploadFile(response: *http.Response, request: http.Request) !void { if (content_type == null) return error.InvalidContentType; // parse multipart data - var multipart = try Multipart.init(request.body, content_type.?); + 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| { From b4b51a3e05436613324851f9d0a3746f2735d4e9 Mon Sep 17 00:00:00 2001 From: Luna Date: Sat, 10 Apr 2021 15:29:15 -0300 Subject: [PATCH 3/5] fix multipart inner part values --- src/main.zig | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/main.zig b/src/main.zig index a3cc50a..e2c9e40 100644 --- a/src/main.zig +++ b/src/main.zig @@ -145,7 +145,9 @@ const Multipart = struct { var single_part_it = std.mem.split(disposition_part, "="); const inner_part_name = single_part_it.next().?; - const inner_part_value = 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; From 1a3c1e354fe688f7bafb6ff283336b9f075ae7ad Mon Sep 17 00:00:00 2001 From: Luna Date: Sat, 10 Apr 2021 15:29:27 -0300 Subject: [PATCH 4/5] multipart: add body reading --- src/main.zig | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/src/main.zig b/src/main.zig index e2c9e40..5fe9a07 100644 --- a/src/main.zig +++ b/src/main.zig @@ -58,6 +58,7 @@ const ContentDisposition = struct { const Part = struct { disposition: ContentDisposition, content_type: []const u8, + body: []const u8, }; const Multipart = struct { @@ -170,9 +171,25 @@ const Multipart = struct { } } + // the rest of the reader until we find a matching boundary is the part body. + // hzzp does not do it for us because it cant find a body encoding + // (content-length, content-encoding) + // + // we can use the fact that we know the reader is FixedBufferStream + // to extract the remaining body, then trim the boundary! + // + // THIS ASSUMES ONLY ONE FILE IS IN THE WIRE. + + const remaining_body = self.stream.buffer[self.stream.pos..self.stream.buffer.len]; + + var end_boundary_buf: [512]u8 = undefined; + const boundary_end_marker = try std.fmt.bufPrint(&end_boundary_buf, "{s}--\r\n", .{self.boundary}); + const actual_body = std.mem.trim(u8, remaining_body, boundary_end_marker); + return Part{ .disposition = content_disposition.?, .content_type = content_type.?, + .body = actual_body, }; } }; From a44af53a8785c57d7aa390cff74bda26788b7d18 Mon Sep 17 00:00:00 2001 From: Luna Date: Sat, 10 Apr 2021 15:29:36 -0300 Subject: [PATCH 5/5] use part body when writing to file --- src/main.zig | 36 ++++++++++++++++++++---------------- 1 file changed, 20 insertions(+), 16 deletions(-) diff --git a/src/main.zig b/src/main.zig index 5fe9a07..4c394e3 100644 --- a/src/main.zig +++ b/src/main.zig @@ -214,23 +214,27 @@ fn uploadFile(response: *http.Response, request: http.Request) !void { var hzzp_buffer: [1024]u8 = undefined; while (try multipart.next(&hzzp_buffer)) |part| { - std.log.info("part: {}", .{part}); + std.log.info( + "got part from multipart request! name='{s}' filename='{s}' content_type='{s}' length={d}", + .{ part.disposition.name, part.disposition.filename, part.content_type, part.body.len }, + ); + + 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(part.body); + + try response.writer().writeAll(image_path); + return; } - - 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 {