Support base64 encoded scripts

Related to #412

Author: ksdme

src/browser/browser.zig

@@ -24,6 +24,7 @@ const ArenaAllocator = std.heap.ArenaAllocator;
 
 const Dump = @import("dump.zig");
 const Mime = @import("mime.zig").Mime;
+const DataURI = @import("datauri.zig").DataURI;
 const parser = @import("netsurf.zig");
 
 const Window = @import("html/window.zig").Window;
@@ -581,10 +582,18 @@ pub const Page = struct {
     // It resolves src using the page's uri.
     // If a base path is given, src is resolved according to the base first.
     // the caller owns the returned string
+    // TODO: We are leaking the memory associated with the response.
     fn fetchData(self: *const Page, src: []const u8, base: ?[]const u8) ![]const u8 {
         log.debug("starting fetch {s}", .{src});
 
         const arena = self.arena;
+
+        // Handle data URIs.
+        const data_uri: ?DataURI = DataURI.parse(arena, src) catch null;
+        if (data_uri) |v| {
+            return v.data;
+        }
+
         var res_src = src;
 
         // if a base path is given, we resolve src using base.

src/browser/datauri.zig

@@ -0,0 +1,79 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+
+// Represents https://developer.mozilla.org/en-US/docs/Web/URI/Reference/Schemes/data
+pub const DataURI = struct {
+    was_base64_encoded: bool,
+    // The contents in the uri. It will be base64 decoded but not prepared in
+    // any way for mime.charset.
+    data: []const u8,
+
+    // Parses data:[<media-type>][;base64],<data>
+    pub fn parse(allocator: Allocator, src: []const u8) !DataURI {
+        if (!std.mem.startsWith(u8, src, "data:")) {
+            return error.Invalid;
+        }
+
+        const uri = src[5..];
+        const data_starts = std.mem.indexOf(u8, uri, ",") orelse return error.Invalid;
+
+        // Extract the encoding.
+        var metadata = uri[0..data_starts];
+        var base64_encoded = false;
+        if (std.mem.endsWith(u8, metadata, ";base64")) {
+            base64_encoded = true;
+            metadata = metadata[0 .. metadata.len - 7];
+        }
+
+        // TODO: Extract mime type. This not trivial because Mime.parse requires
+        // a []u8 and might mutate the src. And, the DataURI.parse references atm
+        // do not have deinit calls.
+
+        // Prepare the data.
+        var data = uri[data_starts + 1 ..];
+        if (base64_encoded) {
+            const decoder = std.base64.standard.Decoder;
+            const decoded_size = try decoder.calcSizeForSlice(data);
+
+            const buffer = try allocator.alloc(u8, decoded_size);
+            errdefer allocator.free(buffer);
+
+            try decoder.decode(buffer, data);
+            data = buffer;
+        }
+
+        return .{
+            .was_base64_encoded = base64_encoded,
+            .data = data,
+        };
+    }
+
+    pub fn deinit(self: *const DataURI, allocator: Allocator) void {
+        if (self.was_base64_encoded) {
+            allocator.free(self.data);
+        }
+    }
+};
+
+const testing = std.testing;
+test "DataURI: parse valid" {
+    try test_valid("data:text/javascript; charset=utf-8;base64,Zm9v", "foo");
+    try test_valid("data:text/javascript; charset=utf-8;,foo", "foo");
+    try test_valid("data:,foo", "foo");
+}
+
+test "DataURI: parse invalid" {
+    try test_invalid("atad:,foo", error.Invalid);
+    try test_invalid("data:foo", error.Invalid);
+    try test_invalid("data:", error.Invalid);
+}
+
+fn test_valid(uri: []const u8, expected: []const u8) !void {
+    const data_uri = try DataURI.parse(std.testing.allocator, uri);
+    defer data_uri.deinit(testing.allocator);
+    try testing.expectEqualStrings(expected, data_uri.data);
+}
+
+fn test_invalid(uri: []const u8, err: anyerror) !void {
+    try testing.expectError(err, DataURI.parse(std.testing.allocator, uri));
+}