Parses the URI or returns an error. This function is not compliant, but is required to parse
some forms of URIs in the wild, such as HTTP Location headers.
The return value will contain strings pointing into the original text.
Each component that is provided, will be non-null.
pub fn parseAfterScheme(scheme: []const u8, text: []const u8) ParseError!Uripub fn parseAfterScheme(scheme: []const u8, text: []const u8) ParseError!Uri {
var uri: Uri = .{ .scheme = scheme, .path = undefined };
var i: usize = 0;
if (std.mem.startsWith(u8, text, "//")) a: {
i = std.mem.findAnyPos(u8, text, 2, &authority_sep) orelse text.len;
const authority = text[2..i];
if (authority.len == 0) {
if (!std.mem.startsWith(u8, text[2..], "/")) return error.InvalidFormat;
break :a;
}
var start_of_host: usize = 0;
// Use findLast to handle unencoded @ in userinfo gracefully,
// e.g. scheme://user:p@ssword@hostname. This deviates from RFC3986
// (which requires @ to be percent-encoded as %40 in userinfo) but
// is more robust against URIs in the wild.
if (std.mem.findLast(u8, authority, "@")) |index| {
start_of_host = index + 1;
const user_info = authority[0..index];
if (std.mem.find(u8, user_info, ":")) |idx| {
uri.user = .{ .percent_encoded = user_info[0..idx] };
if (idx < user_info.len - 1) { // empty password is also "no password"
uri.password = .{ .percent_encoded = user_info[idx + 1 ..] };
}
} else {
uri.user = .{ .percent_encoded = user_info };
uri.password = null;
}
}
// only possible if uri consists of only `userinfo@`
if (start_of_host >= authority.len) break :a;
var end_of_host: usize = authority.len;
// if we see `]` first without `@`
if (authority[start_of_host] == ']') {
return error.InvalidFormat;
}
if (authority.len > start_of_host and authority[start_of_host] == '[') { // IPv6
end_of_host = std.mem.lastIndexOf(u8, authority, "]") orelse return error.InvalidFormat;
end_of_host += 1;
if (std.mem.lastIndexOf(u8, authority, ":")) |index| {
if (index >= end_of_host) { // if not part of the V6 address field
end_of_host = @min(end_of_host, index);
uri.port = std.fmt.parseInt(u16, authority[index + 1 ..], 10) catch return error.InvalidPort;
}
}
} else if (std.mem.lastIndexOf(u8, authority, ":")) |index| {
if (index >= start_of_host) { // if not part of the userinfo field
end_of_host = @min(end_of_host, index);
uri.port = std.fmt.parseInt(u16, authority[index + 1 ..], 10) catch return error.InvalidPort;
}
}
if (start_of_host >= end_of_host) return error.InvalidFormat;
const host = authority[start_of_host..end_of_host];
if (host.len > std.Io.net.HostName.max_len) return error.InvalidHostName;
uri.host = .{ .percent_encoded = host };
}
const path_start = i;
i = std.mem.findAnyPos(u8, text, path_start, &path_sep) orelse text.len;
uri.path = .{ .percent_encoded = text[path_start..i] };
if (std.mem.startsWith(u8, text[i..], "?")) {
const query_start = i + 1;
i = std.mem.findScalarPos(u8, text, query_start, '#') orelse text.len;
uri.query = .{ .percent_encoded = text[query_start..i] };
}
if (std.mem.startsWith(u8, text[i..], "#")) {
uri.fragment = .{ .percent_encoded = text[i + 1 ..] };
}
return uri;
}