Commit c4587dc9f46e15d4fb875a7675bc1aa22138c1ab | zig

author	Jacob Young <jacobly@ziglang.org> 2024-04-09 22:22:08-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2024-04-10 02:11:54-07:00
log	c4587dc9f46e15d4fb875a7675bc1aa22138c1ab
tree	fff3520b8a9ba7492b7ac1d35a5290c535c50ba5
parent	215de3ee67f75e2405c177b262cb5c1cd8c8e343

Uri: propagate per-component encoding

This allows `std.Uri.resolve_inplace` to properly preserve the fact
that `new` is already escaped but `base` may not be.  I originally tried
just moving `raw_uri` around, but it made uri resolution unmanagably
complicated, so I instead added per-component information to `Uri` which
allows extra allocations to be avoided when constructing uris with
components from different sources, and in some cases, deferring the work
all the way to when the uri is printed, where an allocator may not even
be needed.

Closes #19587

7 files changed, 520 insertions(+), 510 deletions(-)

lib
- std
  - Uri.zig
  - http
    Client.zig
    test.zig
  - io.zig
src
- Package
  - Fetch.zig
  - Fetch
    git.zig
- link
  - SpirV.zig

lib/std/Uri.zig+309-334

...	...	@@ -1,156 +1,157 @@
1	1	//! Uniform Resource Identifier (URI) parsing roughly adhering to <https://tools.ietf.org/html/rfc3986>.
2	2	//! Does not do perfect grammar and character class checking, but should be robust against URIs in the wild.
3	3
4		const Uri = @This();
5		const std = @import("std.zig");
6		const testing = std.testing;
7		const Allocator = std.mem.Allocator;
8
9	4	scheme: []const u8,
10		user: ?[]const u8 = null,
11		password: ?[]const u8 = null,
12		host: ?[]const u8 = null,
	5	user: ?Component = null,
	6	password: ?Component = null,
	7	host: ?Component = null,
13	8	port: ?u16 = null,
14		path: []const u8,
15		query: ?[]const u8 = null,
16		fragment: ?[]const u8 = null,
17
18		/// Applies URI encoding and replaces all reserved characters with their respective %XX code.
19		pub fn escapeString(allocator: Allocator, input: []const u8) error{OutOfMemory}![]u8 {
20		return escapeStringWithFn(allocator, input, isUnreserved);
21		}
22
23		pub fn escapePath(allocator: Allocator, input: []const u8) error{OutOfMemory}![]u8 {
24		return escapeStringWithFn(allocator, input, isPathChar);
25		}
26
27		pub fn escapeQuery(allocator: Allocator, input: []const u8) error{OutOfMemory}![]u8 {
28		return escapeStringWithFn(allocator, input, isQueryChar);
29		}
30
31		pub fn writeEscapedString(writer: anytype, input: []const u8) !void {
32		return writeEscapedStringWithFn(writer, input, isUnreserved);
33		}
34
35		pub fn writeEscapedPath(writer: anytype, input: []const u8) !void {
36		return writeEscapedStringWithFn(writer, input, isPathChar);
37		}
38
39		pub fn writeEscapedQuery(writer: anytype, input: []const u8) !void {
40		return writeEscapedStringWithFn(writer, input, isQueryChar);
41		}
42
43		pub fn escapeStringWithFn(allocator: Allocator, input: []const u8, comptime keepUnescaped: fn (c: u8) bool) Allocator.Error![]u8 {
44		var outsize: usize = 0;
45		for (input) \|c\| {
46		outsize += if (keepUnescaped(c)) @as(usize, 1) else 3;
	9	path: Component = Component.empty,
	10	query: ?Component = null,
	11	fragment: ?Component = null,
	12
	13	pub const Component = union(enum) {
	14	/// Invalid characters in this component must be percent encoded
	15	/// before being printed as part of a URI.
	16	raw: []const u8,
	17	/// This component is already percent-encoded, it can be printed
	18	/// directly as part of a URI.
	19	percent_encoded: []const u8,
	20
	21	pub const empty: Component = .{ .percent_encoded = "" };
	22
	23	pub fn isEmpty(component: Component) bool {
	24	return switch (component) {
	25	.raw, .percent_encoded => \|string\| string.len == 0,
	26	};
47	27	}
48		var output = try allocator.alloc(u8, outsize);
49		var outptr: usize = 0;
50	28
51		for (input) \|c\| {
52		if (keepUnescaped(c)) {
53		output[outptr] = c;
54		outptr += 1;
55		} else {
56		var buf: [2]u8 = undefined;
57		_ = std.fmt.bufPrint(&buf, "{X:0>2}", .{c}) catch unreachable;
58
59		output[outptr + 0] = '%';
60		output[outptr + 1] = buf[0];
61		output[outptr + 2] = buf[1];
62		outptr += 3;
63		}
	29	/// Allocates the result with `arena` only if needed, so the result should not be freed.
	30	pub fn toRawMaybeAlloc(
	31	component: Component,
	32	arena: std.mem.Allocator,
	33	) std.mem.Allocator.Error![]const u8 {
	34	return switch (component) {
	35	.raw => \|raw\| raw,
	36	.percent_encoded => \|percent_encoded\| if (std.mem.indexOfScalar(u8, percent_encoded, '%')) \|_\|
	37	try std.fmt.allocPrint(arena, "{raw}", .{component})
	38	else
	39	percent_encoded,
	40	};
64	41	}
65		return output;
66		}
67	42
68		pub fn writeEscapedStringWithFn(writer: anytype, input: []const u8, comptime keepUnescaped: fn (c: u8) bool) @TypeOf(writer).Error!void {
69		for (input) \|c\| {
70		if (keepUnescaped(c)) {
71		try writer.writeByte(c);
72		} else {
73		try writer.print("%{X:0>2}", .{c});
74		}
	43	pub fn format(
	44	component: Component,
	45	comptime fmt_str: []const u8,
	46	_: std.fmt.FormatOptions,
	47	writer: anytype,
	48	) @TypeOf(writer).Error!void {
	49	if (fmt_str.len == 0) {
	50	try writer.print("std.Uri.Component{{ .{s} = \"{}\" }}", .{
	51	@tagName(component),
	52	std.zig.fmtEscapes(switch (component) {
	53	.raw, .percent_encoded => \|string\| string,
	54	}),
	55	});
	56	} else if (comptime std.mem.eql(u8, fmt_str, "raw")) switch (component) {
	57	.raw => \|raw\| try writer.writeAll(raw),
	58	.percent_encoded => \|percent_encoded\| {
	59	var start: usize = 0;
	60	var index: usize = 0;
	61	while (std.mem.indexOfScalarPos(u8, percent_encoded, index, '%')) \|percent\| {
	62	index = percent + 1;
	63	if (percent_encoded.len - index < 2) continue;
	64	const percent_encoded_char =
	65	std.fmt.parseInt(u8, percent_encoded[index..][0..2], 16) catch continue;
	66	try writer.print("{s}{c}", .{
	67	percent_encoded[start..percent],
	68	percent_encoded_char,
	69	});
	70	start = percent + 3;
	71	index = percent + 3;
	72	}
	73	try writer.writeAll(percent_encoded[start..]);
	74	},
	75	} else if (comptime std.mem.eql(u8, fmt_str, "%")) switch (component) {
	76	.raw => \|raw\| try percentEncode(writer, raw, isUnreserved),
	77	.percent_encoded => \|percent_encoded\| try writer.writeAll(percent_encoded),
	78	} else if (comptime std.mem.eql(u8, fmt_str, "user")) switch (component) {
	79	.raw => \|raw\| try percentEncode(writer, raw, isUserChar),
	80	.percent_encoded => \|percent_encoded\| try writer.writeAll(percent_encoded),
	81	} else if (comptime std.mem.eql(u8, fmt_str, "password")) switch (component) {
	82	.raw => \|raw\| try percentEncode(writer, raw, isPasswordChar),
	83	.percent_encoded => \|percent_encoded\| try writer.writeAll(percent_encoded),
	84	} else if (comptime std.mem.eql(u8, fmt_str, "host")) switch (component) {
	85	.raw => \|raw\| try percentEncode(writer, raw, isHostChar),
	86	.percent_encoded => \|percent_encoded\| try writer.writeAll(percent_encoded),
	87	} else if (comptime std.mem.eql(u8, fmt_str, "path")) switch (component) {
	88	.raw => \|raw\| try percentEncode(writer, raw, isPathChar),
	89	.percent_encoded => \|percent_encoded\| try writer.writeAll(percent_encoded),
	90	} else if (comptime std.mem.eql(u8, fmt_str, "query")) switch (component) {
	91	.raw => \|raw\| try percentEncode(writer, raw, isQueryChar),
	92	.percent_encoded => \|percent_encoded\| try writer.writeAll(percent_encoded),
	93	} else if (comptime std.mem.eql(u8, fmt_str, "fragment")) switch (component) {
	94	.raw => \|raw\| try percentEncode(writer, raw, isFragmentChar),
	95	.percent_encoded => \|percent_encoded\| try writer.writeAll(percent_encoded),
	96	} else @compileError("invalid format string '" ++ fmt_str ++ "'");
75	97	}
76		}
77	98
78		/// Parses a URI string and unescapes all %XX where XX is a valid hex number. Otherwise, verbatim copies
79		/// them to the output.
80		pub fn unescapeString(allocator: Allocator, input: []const u8) error{OutOfMemory}![]u8 {
81		var outsize: usize = 0;
82		var inptr: usize = 0;
83		while (inptr < input.len) {
84		if (input[inptr] == '%') {
85		inptr += 1;
86		if (inptr + 2 <= input.len) {
87		_ = std.fmt.parseInt(u8, input[inptr..][0..2], 16) catch {
88		outsize += 3;
89		inptr += 2;
90		continue;
91		};
92		inptr += 2;
93		outsize += 1;
94		} else {
95		outsize += 1;
96		}
97		} else {
98		inptr += 1;
99		outsize += 1;
	99	pub fn percentEncode(
	100	writer: anytype,
	101	raw: []const u8,
	102	comptime isValidChar: fn (u8) bool,
	103	) @TypeOf(writer).Error!void {
	104	var start: usize = 0;
	105	for (raw, 0..) \|char, index\| {
	106	if (isValidChar(char)) continue;
	107	try writer.print("{s}%{X:0>2}", .{ raw[start..index], char });
	108	start = index + 1;
100	109	}
	110	try writer.writeAll(raw[start..]);
101	111	}
	112	};
102	113
103		var output = try allocator.alloc(u8, outsize);
104		var outptr: usize = 0;
105		inptr = 0;
106		while (inptr < input.len) {
107		if (input[inptr] == '%') {
108		inptr += 1;
109		if (inptr + 2 <= input.len) {
110		const value = std.fmt.parseInt(u8, input[inptr..][0..2], 16) catch {
111		output[outptr + 0] = input[inptr + 0];
112		output[outptr + 1] = input[inptr + 1];
113		inptr += 2;
114		outptr += 2;
	114	/// Percent decodes all %XX where XX is a valid hex number.
	115	/// `output` may alias `input` if `output.ptr <= input.ptr`.
	116	/// Mutates and returns a subslice of `output`.
	117	pub fn percentDecodeBackwards(output: []u8, input: []const u8) []u8 {
	118	var input_index = input.len;
	119	var output_index = output.len;
	120	while (input_index > 0) {
	121	if (input_index >= 3) {
	122	const maybe_percent_encoded = input[input_index - 3 ..][0..3];
	123	if (maybe_percent_encoded[0] == '%') {
	124	if (std.fmt.parseInt(u8, maybe_percent_encoded[1..], 16)) \|percent_encoded_char\| {
	125	input_index -= maybe_percent_encoded.len;
	126	output_index -= 1;
	127	output[output_index] = percent_encoded_char;
115	128	continue;
116		};
117
118		output[outptr] = value;
119
120		inptr += 2;
121		outptr += 1;
122		} else {
123		output[outptr] = input[inptr - 1];
124		outptr += 1;
	129	} else \|_\| {}
125	130	}
126		} else {
127		output[outptr] = input[inptr];
128		inptr += 1;
129		outptr += 1;
130	131	}
	132	input_index -= 1;
	133	output_index -= 1;
	134	output[output_index] = input[input_index];
131	135	}
132		return output;
	136	return output[output_index..];
	137	}
	138
	139	/// Percent decodes all %XX where XX is a valid hex number.
	140	/// Mutates and returns a subslice of `buffer`.
	141	pub fn percentDecodeInPlace(buffer: []u8) []u8 {
	142	return percentDecodeBackwards(buffer, buffer);
133	143	}
134	144
135	145	pub const ParseError = error{ UnexpectedCharacter, InvalidFormat, InvalidPort };
136	146
137	147	/// Parses the URI or returns an error. This function is not compliant, but is required to parse
138	148	/// some forms of URIs in the wild, such as HTTP Location headers.
139		/// The return value will contain unescaped strings pointing into the
140		/// original `text`. Each component that is provided, will be non-`null`.
141		pub fn parseWithoutScheme(text: []const u8) ParseError!Uri {
	149	/// The return value will contain strings pointing into the original `text`.
	150	/// Each component that is provided, will be non-`null`.
	151	pub fn parseAfterScheme(scheme: []const u8, text: []const u8) ParseError!Uri {
142	152	var reader = SliceReader{ .slice = text };
143	153
144		var uri = Uri{
145		.scheme = "",
146		.user = null,
147		.password = null,
148		.host = null,
149		.port = null,
150		.path = "", // path is always set, but empty by default.
151		.query = null,
152		.fragment = null,
153		};
	154	var uri: Uri = .{ .scheme = scheme, .path = undefined };
154	155
155	156	if (reader.peekPrefix("//")) a: { // authority part
156	157	std.debug.assert(reader.get().? == '/');
...	...	@@ -167,12 +168,12 @@ pub fn parseWithoutScheme(text: []const u8) ParseError!Uri {
167	168	const user_info = authority[0..index];
168	169
169	170	if (std.mem.indexOf(u8, user_info, ":")) \|idx\| {
170		uri.user = user_info[0..idx];
	171	uri.user = .{ .percent_encoded = user_info[0..idx] };
171	172	if (idx < user_info.len - 1) { // empty password is also "no password"
172		uri.password = user_info[idx + 1 ..];
	173	uri.password = .{ .percent_encoded = user_info[idx + 1 ..] };
173	174	}
174	175	} else {
175		uri.user = user_info;
	176	uri.user = .{ .percent_encoded = user_info };
176	177	uri.password = null;
177	178	}
178	179	}
...	...	@@ -205,19 +206,19 @@ pub fn parseWithoutScheme(text: []const u8) ParseError!Uri {
205	206	}
206	207
207	208	if (start_of_host >= end_of_host) return error.InvalidFormat;
208		uri.host = authority[start_of_host..end_of_host];
	209	uri.host = .{ .percent_encoded = authority[start_of_host..end_of_host] };
209	210	}
210	211
211		uri.path = reader.readUntil(isPathSeparator);
	212	uri.path = .{ .percent_encoded = reader.readUntil(isPathSeparator) };
212	213
213	214	if ((reader.peek() orelse 0) == '?') { // query part
214	215	std.debug.assert(reader.get().? == '?');
215		uri.query = reader.readUntil(isQuerySeparator);
	216	uri.query = .{ .percent_encoded = reader.readUntil(isQuerySeparator) };
216	217	}
217	218
218	219	if ((reader.peek() orelse 0) == '#') { // fragment part
219	220	std.debug.assert(reader.get().? == '#');
220		uri.fragment = reader.readUntilEof();
	221	uri.fragment = .{ .percent_encoded = reader.readUntilEof() };
221	222	}
222	223
223	224	return uri;
...	...	@@ -241,9 +242,6 @@ pub const WriteToStreamOptions = struct {
241	242
242	243	/// When true, include the fragment part of the URI. Ignored when `path` is false.
243	244	fragment: bool = false,
244
245		/// When true, do not escape any part of the URI.
246		raw: bool = false,
247	245	};
248	246
249	247	pub fn writeToStream(
...	...	@@ -252,80 +250,51 @@ pub fn writeToStream(
252	250	writer: anytype,
253	251	) @TypeOf(writer).Error!void {
254	252	if (options.scheme) {
255		try writer.writeAll(uri.scheme);
256		try writer.writeAll(":");
257
	253	try writer.print("{s}:", .{uri.scheme});
258	254	if (options.authority and uri.host != null) {
259	255	try writer.writeAll("//");
260	256	}
261	257	}
262
263	258	if (options.authority) {
264	259	if (options.authentication and uri.host != null) {
265	260	if (uri.user) \|user\| {
266		try writer.writeAll(user);
	261	try writer.print("{user}", .{user});
267	262	if (uri.password) \|password\| {
268		try writer.writeAll(":");
269		try writer.writeAll(password);
	263	try writer.print(":{password}", .{password});
270	264	}
271		try writer.writeAll("@");
	265	try writer.writeByte('@');
272	266	}
273	267	}
274
275	268	if (uri.host) \|host\| {
276		try writer.writeAll(host);
277
278		if (uri.port) \|port\| {
279		try writer.writeAll(":");
280		try std.fmt.formatInt(port, 10, .lower, .{}, writer);
281		}
	269	try writer.print("{host}", .{host});
	270	if (uri.port) \|port\| try writer.print(":{d}", .{port});
282	271	}
283	272	}
284
285	273	if (options.path) {
286		if (uri.path.len == 0) {
287		try writer.writeAll("/");
288		} else if (options.raw) {
289		try writer.writeAll(uri.path);
290		} else {
291		try writeEscapedPath(writer, uri.path);
	274	try writer.print("{path}", .{
	275	if (uri.path.isEmpty()) Uri.Component{ .percent_encoded = "/" } else uri.path,
	276	});
	277	if (options.query) {
	278	if (uri.query) \|query\| try writer.print("?{query}", .{query});
	279	}
	280	if (options.fragment) {
	281	if (uri.fragment) \|fragment\| try writer.print("#{fragment}", .{fragment});
292	282	}
293
294		if (options.query) if (uri.query) \|q\| {
295		try writer.writeAll("?");
296		if (options.raw) {
297		try writer.writeAll(q);
298		} else {
299		try writeEscapedQuery(writer, q);
300		}
301		};
302
303		if (options.fragment) if (uri.fragment) \|f\| {
304		try writer.writeAll("#");
305		if (options.raw) {
306		try writer.writeAll(f);
307		} else {
308		try writeEscapedQuery(writer, f);
309		}
310		};
311	283	}
312	284	}
313	285
314	286	pub fn format(
315	287	uri: Uri,
316		comptime fmt: []const u8,
317		options: std.fmt.FormatOptions,
	288	comptime fmt_str: []const u8,
	289	_: std.fmt.FormatOptions,
318	290	writer: anytype,
319	291	) @TypeOf(writer).Error!void {
320		_ = options;
321
322		const scheme = comptime std.mem.indexOf(u8, fmt, ";") != null or fmt.len == 0;
323		const authentication = comptime std.mem.indexOf(u8, fmt, "@") != null or fmt.len == 0;
324		const authority = comptime std.mem.indexOf(u8, fmt, "+") != null or fmt.len == 0;
325		const path = comptime std.mem.indexOf(u8, fmt, "/") != null or fmt.len == 0;
326		const query = comptime std.mem.indexOf(u8, fmt, "?") != null or fmt.len == 0;
327		const fragment = comptime std.mem.indexOf(u8, fmt, "#") != null or fmt.len == 0;
328		const raw = comptime std.mem.indexOf(u8, fmt, "r") != null or fmt.len == 0;
	292	const scheme = comptime std.mem.indexOfScalar(u8, fmt_str, ';') != null or fmt_str.len == 0;
	293	const authentication = comptime std.mem.indexOfScalar(u8, fmt_str, '@') != null or fmt_str.len == 0;
	294	const authority = comptime std.mem.indexOfScalar(u8, fmt_str, '+') != null or fmt_str.len == 0;
	295	const path = comptime std.mem.indexOfScalar(u8, fmt_str, '/') != null or fmt_str.len == 0;
	296	const query = comptime std.mem.indexOfScalar(u8, fmt_str, '?') != null or fmt_str.len == 0;
	297	const fragment = comptime std.mem.indexOfScalar(u8, fmt_str, '#') != null or fmt_str.len == 0;
329	298
330	299	return writeToStream(uri, .{
331	300	.scheme = scheme,
...	...	@@ -334,12 +303,11 @@ pub fn format(
334	303	.path = path,
335	304	.query = query,
336	305	.fragment = fragment,
337		.raw = raw,
338	306	}, writer);
339	307	}
340	308
341	309	/// Parses the URI or returns an error.
342		/// The return value will contain unescaped strings pointing into the
	310	/// The return value will contain strings pointing into the
343	311	/// original `text`. Each component that is provided, will be non-`null`.
344	312	pub fn parse(text: []const u8) ParseError!Uri {
345	313	var reader: SliceReader = .{ .slice = text };
...	...	@@ -353,42 +321,32 @@ pub fn parse(text: []const u8) ParseError!Uri {
353	321	return error.InvalidFormat;
354	322	}
355	323
356		var uri = try parseWithoutScheme(reader.readUntilEof());
357		uri.scheme = scheme;
358
359		return uri;
	324	return parseAfterScheme(scheme, reader.readUntilEof());
360	325	}
361	326
362		pub const ResolveInplaceError = ParseError \|\| error{OutOfMemory};
	327	pub const ResolveInPlaceError = ParseError \|\| error{NoSpaceLeft};
363	328
364	329	/// Resolves a URI against a base URI, conforming to RFC 3986, Section 5.
365		/// Copies `new` to the beginning of `aux_buf`, allowing the slices to overlap,
	330	/// Copies `new` to the beginning of `aux_buf.*`, allowing the slices to overlap,
366	331	/// then parses `new` as a URI, and then resolves the path in place.
367	332	/// If a merge needs to take place, the newly constructed path will be stored
368		/// in `aux_buf` just after the copied `new`.
369		pub fn resolve_inplace(base: Uri, new: []const u8, aux_buf: []u8) ResolveInplaceError!Uri {
370		std.mem.copyForwards(u8, aux_buf, new);
	333	/// in `aux_buf.` just after the copied `new`, and `aux_buf.` will be modified
	334	/// to only contain the remaining unused space.
	335	pub fn resolve_inplace(base: Uri, new: []const u8, aux_buf: *[]u8) ResolveInPlaceError!Uri {
	336	std.mem.copyForwards(u8, aux_buf.*, new);
371	337	// At this point, new is an invalid pointer.
372		const new_mut = aux_buf[0..new.len];
373
374		const new_parsed, const has_scheme = p: {
375		break :p .{
376		parse(new_mut) catch \|first_err\| {
377		break :p .{
378		parseWithoutScheme(new_mut) catch return first_err,
379		false,
380		};
381		},
382		true,
383		};
384		};
	338	const new_mut = aux_buf.*[0..new.len];
	339	aux_buf.* = aux_buf.*[new.len..];
385	340
	341	const new_parsed = parse(new_mut) catch \|err\|
	342	(parseAfterScheme("", new_mut) catch return err);
386	343	// As you can see above, `new_mut` is not a const pointer.
387		const new_path: []u8 = @constCast(new_parsed.path);
	344	const new_path: []u8 = @constCast(new_parsed.path.percent_encoded);
388	345
389		if (has_scheme) return .{
	346	if (new_parsed.scheme.len > 0) return .{
390	347	.scheme = new_parsed.scheme,
391	348	.user = new_parsed.user,
	349	.password = new_parsed.password,
392	350	.host = new_parsed.host,
393	351	.port = new_parsed.port,
394	352	.path = remove_dot_segments(new_path),
...	...	@@ -399,6 +357,7 @@ pub fn resolve_inplace(base: Uri, new: []const u8, aux_buf: []u8) ResolveInplace
399	357	if (new_parsed.host) \|host\| return .{
400	358	.scheme = base.scheme,
401	359	.user = new_parsed.user,
	360	.password = new_parsed.password,
402	361	.host = host,
403	362	.port = new_parsed.port,
404	363	.path = remove_dot_segments(new_path),
...	...	@@ -406,28 +365,21 @@ pub fn resolve_inplace(base: Uri, new: []const u8, aux_buf: []u8) ResolveInplace
406	365	.fragment = new_parsed.fragment,
407	366	};
408	367
409		const path, const query = b: {
410		if (new_path.len == 0)
411		break :b .{
412		base.path,
413		new_parsed.query orelse base.query,
414		};
415
416		if (new_path[0] == '/')
417		break :b .{
418		remove_dot_segments(new_path),
419		new_parsed.query,
420		};
421
422		break :b .{
423		try merge_paths(base.path, new_path, aux_buf[new_mut.len..]),
424		new_parsed.query,
425		};
	368	const path, const query = if (new_path.len == 0) .{
	369	base.path,
	370	new_parsed.query orelse base.query,
	371	} else if (new_path[0] == '/') .{
	372	remove_dot_segments(new_path),
	373	new_parsed.query,
	374	} else .{
	375	try merge_paths(base.path, new_path, aux_buf),
	376	new_parsed.query,
426	377	};
427	378
428	379	return .{
429	380	.scheme = base.scheme,
430	381	.user = base.user,
	382	.password = base.password,
431	383	.host = base.host,
432	384	.port = base.port,
433	385	.path = path,
...	...	@@ -437,7 +389,7 @@ pub fn resolve_inplace(base: Uri, new: []const u8, aux_buf: []u8) ResolveInplace
437	389	}
438	390
439	391	/// In-place implementation of RFC 3986, Section 5.2.4.
440		fn remove_dot_segments(path: []u8) []u8 {
	392	fn remove_dot_segments(path: []u8) Component {
441	393	var in_i: usize = 0;
442	394	var out_i: usize = 0;
443	395	while (in_i < path.len) {
...	...	@@ -476,28 +428,28 @@ fn remove_dot_segments(path: []u8) []u8 {
476	428	}
477	429	}
478	430	}
479		return path[0..out_i];
	431	return .{ .percent_encoded = path[0..out_i] };
480	432	}
481	433
482	434	test remove_dot_segments {
483	435	{
484	436	var buffer = "/a/b/c/./../../g".*;
485		try std.testing.expectEqualStrings("/a/g", remove_dot_segments(&buffer));
	437	try std.testing.expectEqualStrings("/a/g", remove_dot_segments(&buffer).percent_encoded);
486	438	}
487	439	}
488	440
489	441	/// 5.2.3. Merge Paths
490		fn merge_paths(base: []const u8, new: []u8, aux: []u8) error{OutOfMemory}![]u8 {
491		if (aux.len < base.len + 1 + new.len) return error.OutOfMemory;
492		if (base.len == 0) {
493		aux[0] = '/';
494		@memcpy(aux[1..][0..new.len], new);
495		return remove_dot_segments(aux[0 .. new.len + 1]);
	442	fn merge_paths(base: Component, new: []u8, aux_buf: *[]u8) error{NoSpaceLeft}!Component {
	443	var aux = std.io.fixedBufferStream(aux_buf.*);
	444	if (!base.isEmpty()) {
	445	try aux.writer().print("{path}", .{base});
	446	aux.pos = std.mem.lastIndexOfScalar(u8, aux.getWritten(), '/') orelse
	447	return remove_dot_segments(new);
496	448	}
497		const pos = std.mem.lastIndexOfScalar(u8, base, '/') orelse return remove_dot_segments(new);
498		@memcpy(aux[0 .. pos + 1], base[0 .. pos + 1]);
499		@memcpy(aux[pos + 1 ..][0..new.len], new);
500		return remove_dot_segments(aux[0 .. pos + 1 + new.len]);
	449	try aux.writer().print("/{s}", .{new});
	450	const merged_path = remove_dot_segments(aux.getWritten());
	451	aux_buf.* = aux_buf.*[merged_path.percent_encoded.len..];
	452	return merged_path;
501	453	}
502	454
503	455	const SliceReader = struct {
...	...	@@ -561,13 +513,6 @@ fn isSchemeChar(c: u8) bool {
561	513	};
562	514	}
563	515
564		fn isAuthoritySeparator(c: u8) bool {
565		return switch (c) {
566		'/', '?', '#' => true,
567		else => false,
568		};
569		}
570
571	516	/// reserved = gen-delims / sub-delims
572	517	fn isReserved(c: u8) bool {
573	518	return isGenLimit(c) or isSubLimit(c);
...	...	@@ -598,19 +543,40 @@ fn isUnreserved(c: u8) bool {
598	543	};
599	544	}
600	545
601		fn isPathSeparator(c: u8) bool {
602		return switch (c) {
603		'?', '#' => true,
604		else => false,
605		};
	546	fn isUserChar(c: u8) bool {
	547	return isUnreserved(c) or isSubLimit(c);
	548	}
	549
	550	fn isPasswordChar(c: u8) bool {
	551	return isUserChar(c) or c == ':';
	552	}
	553
	554	fn isHostChar(c: u8) bool {
	555	return isPasswordChar(c) or c == '[' or c == ']';
606	556	}
607	557
608	558	fn isPathChar(c: u8) bool {
609		return isUnreserved(c) or isSubLimit(c) or c == '/' or c == ':' or c == '@';
	559	return isUserChar(c) or c == '/' or c == ':' or c == '@';
610	560	}
611	561
612	562	fn isQueryChar(c: u8) bool {
613		return isPathChar(c) or c == '?' or c == '%';
	563	return isPathChar(c) or c == '?';
	564	}
	565
	566	const isFragmentChar = isQueryChar;
	567
	568	fn isAuthoritySeparator(c: u8) bool {
	569	return switch (c) {
	570	'/', '?', '#' => true,
	571	else => false,
	572	};
	573	}
	574
	575	fn isPathSeparator(c: u8) bool {
	576	return switch (c) {
	577	'?', '#' => true,
	578	else => false,
	579	};
614	580	}
615	581
616	582	fn isQuerySeparator(c: u8) bool {
...	...	@@ -623,92 +589,92 @@ fn isQuerySeparator(c: u8) bool {
623	589	test "basic" {
624	590	const parsed = try parse("https://ziglang.org/download");
625	591	try testing.expectEqualStrings("https", parsed.scheme);
626		try testing.expectEqualStrings("ziglang.org", parsed.host orelse return error.UnexpectedNull);
627		try testing.expectEqualStrings("/download", parsed.path);
	592	try testing.expectEqualStrings("ziglang.org", parsed.host.?.percent_encoded);
	593	try testing.expectEqualStrings("/download", parsed.path.percent_encoded);
628	594	try testing.expectEqual(@as(?u16, null), parsed.port);
629	595	}
630	596
631	597	test "with port" {
632	598	const parsed = try parse("http://example:1337/");
633	599	try testing.expectEqualStrings("http", parsed.scheme);
634		try testing.expectEqualStrings("example", parsed.host orelse return error.UnexpectedNull);
635		try testing.expectEqualStrings("/", parsed.path);
	600	try testing.expectEqualStrings("example", parsed.host.?.percent_encoded);
	601	try testing.expectEqualStrings("/", parsed.path.percent_encoded);
636	602	try testing.expectEqual(@as(?u16, 1337), parsed.port);
637	603	}
638	604
639	605	test "should fail gracefully" {
640		try std.testing.expectEqual(@as(ParseError!Uri, error.InvalidFormat), parse("foobar://"));
	606	try std.testing.expectError(error.InvalidFormat, parse("foobar://"));
641	607	}
642	608
643	609	test "file" {
644	610	const parsed = try parse("file:///");
645		try std.testing.expectEqualSlices(u8, "file", parsed.scheme);
646		try std.testing.expectEqual(@as(?[]const u8, null), parsed.host);
647		try std.testing.expectEqualSlices(u8, "/", parsed.path);
	611	try std.testing.expectEqualStrings("file", parsed.scheme);
	612	try std.testing.expectEqual(@as(?Component, null), parsed.host);
	613	try std.testing.expectEqualStrings("/", parsed.path.percent_encoded);
648	614
649	615	const parsed2 = try parse("file:///an/absolute/path/to/something");
650		try std.testing.expectEqualSlices(u8, "file", parsed2.scheme);
651		try std.testing.expectEqual(@as(?[]const u8, null), parsed2.host);
652		try std.testing.expectEqualSlices(u8, "/an/absolute/path/to/something", parsed2.path);
	616	try std.testing.expectEqualStrings("file", parsed2.scheme);
	617	try std.testing.expectEqual(@as(?Component, null), parsed2.host);
	618	try std.testing.expectEqualStrings("/an/absolute/path/to/something", parsed2.path.percent_encoded);
653	619
654	620	const parsed3 = try parse("file://localhost/an/absolute/path/to/another/thing/");
655		try std.testing.expectEqualSlices(u8, "file", parsed3.scheme);
656		try std.testing.expectEqualSlices(u8, "localhost", parsed3.host.?);
657		try std.testing.expectEqualSlices(u8, "/an/absolute/path/to/another/thing/", parsed3.path);
	621	try std.testing.expectEqualStrings("file", parsed3.scheme);
	622	try std.testing.expectEqualStrings("localhost", parsed3.host.?.percent_encoded);
	623	try std.testing.expectEqualStrings("/an/absolute/path/to/another/thing/", parsed3.path.percent_encoded);
658	624	}
659	625
660	626	test "scheme" {
661		try std.testing.expectEqualSlices(u8, "http", (try parse("http:_")).scheme);
662		try std.testing.expectEqualSlices(u8, "scheme-mee", (try parse("scheme-mee:_")).scheme);
663		try std.testing.expectEqualSlices(u8, "a.b.c", (try parse("a.b.c:_")).scheme);
664		try std.testing.expectEqualSlices(u8, "ab+", (try parse("ab+:_")).scheme);
665		try std.testing.expectEqualSlices(u8, "X+++", (try parse("X+++:_")).scheme);
666		try std.testing.expectEqualSlices(u8, "Y+-.", (try parse("Y+-.:_")).scheme);
	627	try std.testing.expectEqualStrings("http", (try parse("http:_")).scheme);
	628	try std.testing.expectEqualStrings("scheme-mee", (try parse("scheme-mee:_")).scheme);
	629	try std.testing.expectEqualStrings("a.b.c", (try parse("a.b.c:_")).scheme);
	630	try std.testing.expectEqualStrings("ab+", (try parse("ab+:_")).scheme);
	631	try std.testing.expectEqualStrings("X+++", (try parse("X+++:_")).scheme);
	632	try std.testing.expectEqualStrings("Y+-.", (try parse("Y+-.:_")).scheme);
667	633	}
668	634
669	635	test "authority" {
670		try std.testing.expectEqualSlices(u8, "hostname", (try parse("scheme://hostname")).host.?);
	636	try std.testing.expectEqualStrings("hostname", (try parse("scheme://hostname")).host.?.percent_encoded);
671	637
672		try std.testing.expectEqualSlices(u8, "hostname", (try parse("scheme://userinfo@hostname")).host.?);
673		try std.testing.expectEqualSlices(u8, "userinfo", (try parse("scheme://userinfo@hostname")).user.?);
674		try std.testing.expectEqual(@as(?[]const u8, null), (try parse("scheme://userinfo@hostname")).password);
675		try std.testing.expectEqual(@as(?[]const u8, null), (try parse("scheme://userinfo@")).host);
	638	try std.testing.expectEqualStrings("hostname", (try parse("scheme://userinfo@hostname")).host.?.percent_encoded);
	639	try std.testing.expectEqualStrings("userinfo", (try parse("scheme://userinfo@hostname")).user.?.percent_encoded);
	640	try std.testing.expectEqual(@as(?Component, null), (try parse("scheme://userinfo@hostname")).password);
	641	try std.testing.expectEqual(@as(?Component, null), (try parse("scheme://userinfo@")).host);
676	642
677		try std.testing.expectEqualSlices(u8, "hostname", (try parse("scheme://user:password@hostname")).host.?);
678		try std.testing.expectEqualSlices(u8, "user", (try parse("scheme://user:password@hostname")).user.?);
679		try std.testing.expectEqualSlices(u8, "password", (try parse("scheme://user:password@hostname")).password.?);
	643	try std.testing.expectEqualStrings("hostname", (try parse("scheme://user:password@hostname")).host.?.percent_encoded);
	644	try std.testing.expectEqualStrings("user", (try parse("scheme://user:password@hostname")).user.?.percent_encoded);
	645	try std.testing.expectEqualStrings("password", (try parse("scheme://user:password@hostname")).password.?.percent_encoded);
680	646
681		try std.testing.expectEqualSlices(u8, "hostname", (try parse("scheme://hostname:0")).host.?);
	647	try std.testing.expectEqualStrings("hostname", (try parse("scheme://hostname:0")).host.?.percent_encoded);
682	648	try std.testing.expectEqual(@as(u16, 1234), (try parse("scheme://hostname:1234")).port.?);
683	649
684		try std.testing.expectEqualSlices(u8, "hostname", (try parse("scheme://userinfo@hostname:1234")).host.?);
	650	try std.testing.expectEqualStrings("hostname", (try parse("scheme://userinfo@hostname:1234")).host.?.percent_encoded);
685	651	try std.testing.expectEqual(@as(u16, 1234), (try parse("scheme://userinfo@hostname:1234")).port.?);
686		try std.testing.expectEqualSlices(u8, "userinfo", (try parse("scheme://userinfo@hostname:1234")).user.?);
687		try std.testing.expectEqual(@as(?[]const u8, null), (try parse("scheme://userinfo@hostname:1234")).password);
	652	try std.testing.expectEqualStrings("userinfo", (try parse("scheme://userinfo@hostname:1234")).user.?.percent_encoded);
	653	try std.testing.expectEqual(@as(?Component, null), (try parse("scheme://userinfo@hostname:1234")).password);
688	654
689		try std.testing.expectEqualSlices(u8, "hostname", (try parse("scheme://user:password@hostname:1234")).host.?);
	655	try std.testing.expectEqualStrings("hostname", (try parse("scheme://user:password@hostname:1234")).host.?.percent_encoded);
690	656	try std.testing.expectEqual(@as(u16, 1234), (try parse("scheme://user:password@hostname:1234")).port.?);
691		try std.testing.expectEqualSlices(u8, "user", (try parse("scheme://user:password@hostname:1234")).user.?);
692		try std.testing.expectEqualSlices(u8, "password", (try parse("scheme://user:password@hostname:1234")).password.?);
	657	try std.testing.expectEqualStrings("user", (try parse("scheme://user:password@hostname:1234")).user.?.percent_encoded);
	658	try std.testing.expectEqualStrings("password", (try parse("scheme://user:password@hostname:1234")).password.?.percent_encoded);
693	659	}
694	660
695	661	test "authority.password" {
696		try std.testing.expectEqualSlices(u8, "username", (try parse("scheme://username@a")).user.?);
697		try std.testing.expectEqual(@as(?[]const u8, null), (try parse("scheme://username@a")).password);
	662	try std.testing.expectEqualStrings("username", (try parse("scheme://username@a")).user.?.percent_encoded);
	663	try std.testing.expectEqual(@as(?Component, null), (try parse("scheme://username@a")).password);
698	664
699		try std.testing.expectEqualSlices(u8, "username", (try parse("scheme://username:@a")).user.?);
700		try std.testing.expectEqual(@as(?[]const u8, null), (try parse("scheme://username:@a")).password);
	665	try std.testing.expectEqualStrings("username", (try parse("scheme://username:@a")).user.?.percent_encoded);
	666	try std.testing.expectEqual(@as(?Component, null), (try parse("scheme://username:@a")).password);
701	667
702		try std.testing.expectEqualSlices(u8, "username", (try parse("scheme://username:password@a")).user.?);
703		try std.testing.expectEqualSlices(u8, "password", (try parse("scheme://username:password@a")).password.?);
	668	try std.testing.expectEqualStrings("username", (try parse("scheme://username:password@a")).user.?.percent_encoded);
	669	try std.testing.expectEqualStrings("password", (try parse("scheme://username:password@a")).password.?.percent_encoded);
704	670
705		try std.testing.expectEqualSlices(u8, "username", (try parse("scheme://username::@a")).user.?);
706		try std.testing.expectEqualSlices(u8, ":", (try parse("scheme://username::@a")).password.?);
	671	try std.testing.expectEqualStrings("username", (try parse("scheme://username::@a")).user.?.percent_encoded);
	672	try std.testing.expectEqualStrings(":", (try parse("scheme://username::@a")).password.?.percent_encoded);
707	673	}
708	674
709	675	fn testAuthorityHost(comptime hostlist: anytype) !void {
710	676	inline for (hostlist) \|hostname\| {
711		try std.testing.expectEqualSlices(u8, hostname, (try parse("scheme://" ++ hostname)).host.?);
	677	try std.testing.expectEqualStrings(hostname, (try parse("scheme://" ++ hostname)).host.?.percent_encoded);
712	678	}
713	679	}
714	680
...	...	@@ -761,11 +727,11 @@ test "RFC example 1" {
761	727	.scheme = uri[0..3],
762	728	.user = null,
763	729	.password = null,
764		.host = uri[6..17],
	730	.host = .{ .percent_encoded = uri[6..17] },
765	731	.port = 8042,
766		.path = uri[22..33],
767		.query = uri[34..45],
768		.fragment = uri[46..50],
	732	.path = .{ .percent_encoded = uri[22..33] },
	733	.query = .{ .percent_encoded = uri[34..45] },
	734	.fragment = .{ .percent_encoded = uri[46..50] },
769	735	}, try parse(uri));
770	736	}
771	737
...	...	@@ -777,7 +743,7 @@ test "RFC example 2" {
777	743	.password = null,
778	744	.host = null,
779	745	.port = null,
780		.path = uri[4..],
	746	.path = .{ .percent_encoded = uri[4..] },
781	747	.query = null,
782	748	.fragment = null,
783	749	}, try parse(uri));
...	...	@@ -838,55 +804,60 @@ test "Special test" {
838	804	_ = try parse("https://www.youtube.com/watch?v=dQw4w9WgXcQ&feature=youtu.be&t=0");
839	805	}
840	806
841		test "URI escaping" {
842		const input = "\\ö/ äöß ~~.adas-https://canvas:123/#ads&&sad";
843		const expected = "%5C%C3%B6%2F%20%C3%A4%C3%B6%C3%9F%20~~.adas-https%3A%2F%2Fcanvas%3A123%2F%23ads%26%26sad";
	807	test "URI percent encoding" {
	808	try std.testing.expectFmt(
	809	"%5C%C3%B6%2F%20%C3%A4%C3%B6%C3%9F%20~~.adas-https%3A%2F%2Fcanvas%3A123%2F%23ads%26%26sad",
	810	"{%}",
	811	.{Component{ .raw = "\\ö/ äöß ~~.adas-https://canvas:123/#ads&&sad" }},
	812	);
	813	}
844	814
845		const actual = try escapeString(std.testing.allocator, input);
846		defer std.testing.allocator.free(actual);
	815	test "URI percent decoding" {
	816	{
	817	const expected = "\\ö/ äöß ~~.adas-https://canvas:123/#ads&&sad";
	818	var input = "%5C%C3%B6%2F%20%C3%A4%C3%B6%C3%9F%20~~.adas-https%3A%2F%2Fcanvas%3A123%2F%23ads%26%26sad".*;
847	819
848		try std.testing.expectEqualSlices(u8, expected, actual);
849		}
	820	try std.testing.expectFmt(expected, "{raw}", .{Component{ .percent_encoded = &input }});
	821
	822	var output: [expected.len]u8 = undefined;
	823	try std.testing.expectEqualStrings(percentDecodeBackwards(&output, &input), expected);
	824
	825	try std.testing.expectEqualStrings(expected, percentDecodeInPlace(&input));
	826	}
850	827
851		test "URI unescaping" {
852		const input = "%5C%C3%B6%2F%20%C3%A4%C3%B6%C3%9F%20~~.adas-https%3A%2F%2Fcanvas%3A123%2F%23ads%26%26sad";
853		const expected = "\\ö/ äöß ~~.adas-https://canvas:123/#ads&&sad";
	828	{
	829	const expected = "/abc%";
	830	var input = expected.*;
854	831
855		const actual = try unescapeString(std.testing.allocator, input);
856		defer std.testing.allocator.free(actual);
	832	try std.testing.expectFmt(expected, "{raw}", .{Component{ .percent_encoded = &input }});
857	833
858		try std.testing.expectEqualSlices(u8, expected, actual);
	834	var output: [expected.len]u8 = undefined;
	835	try std.testing.expectEqualStrings(percentDecodeBackwards(&output, &input), expected);
859	836
860		const decoded = try unescapeString(std.testing.allocator, "/abc%");
861		defer std.testing.allocator.free(decoded);
862		try std.testing.expectEqualStrings("/abc%", decoded);
	837	try std.testing.expectEqualStrings(expected, percentDecodeInPlace(&input));
	838	}
863	839	}
864	840
865		test "URI query escaping" {
	841	test "URI query encoding" {
866	842	const address = "https://objects.githubusercontent.com/?response-content-type=application%2Foctet-stream";
867	843	const parsed = try Uri.parse(address);
868	844
869		// format the URI to escape it
870		const formatted_uri = try std.fmt.allocPrint(std.testing.allocator, "{/?}", .{parsed});
871		defer std.testing.allocator.free(formatted_uri);
872		try std.testing.expectEqualStrings("/?response-content-type=application%2Foctet-stream", formatted_uri);
	845	// format the URI to percent encode it
	846	try std.testing.expectFmt("/?response-content-type=application%2Foctet-stream", "{/?}", .{parsed});
873	847	}
874	848
875	849	test "format" {
876		const uri = Uri{
	850	const uri: Uri = .{
877	851	.scheme = "file",
878	852	.user = null,
879	853	.password = null,
880	854	.host = null,
881	855	.port = null,
882		.path = "/foo/bar/baz",
	856	.path = .{ .raw = "/foo/bar/baz" },
883	857	.query = null,
884	858	.fragment = null,
885	859	};
886		var buf = std.ArrayList(u8).init(std.testing.allocator);
887		defer buf.deinit();
888		try buf.writer().print("{;/?#}", .{uri});
889		try std.testing.expectEqualSlices(u8, "file:/foo/bar/baz", buf.items);
	860	try std.testing.expectFmt("file:/foo/bar/baz", "{;/?#}", .{uri});
890	861	}
891	862
892	863	test "URI malformed input" {
...	...	@@ -894,3 +865,7 @@ test "URI malformed input" {
894	865	try std.testing.expectError(error.InvalidFormat, std.Uri.parse("http://]@["));
895	866	try std.testing.expectError(error.InvalidFormat, std.Uri.parse("http://lo]s\x85hc@[/8\x10?0Q"));
896	867	}
	868
	869	const std = @import("std.zig");
	870	const testing = std.testing;
	871	const Uri = @This();

lib/std/http/Client.zig+108-128

...	...	@@ -771,17 +771,41 @@ pub const Request = struct {
771	771	req.client.connection_pool.release(req.client.allocator, req.connection.?);
772	772	req.connection = null;
773	773
774		const protocol = protocol_map.get(uri.scheme) orelse return error.UnsupportedUrlScheme;
	774	var server_header = std.heap.FixedBufferAllocator.init(req.response.parser.header_bytes_buffer);
	775	defer req.response.parser.header_bytes_buffer = server_header.buffer[server_header.end_index..];
	776	const protocol, const valid_uri = try validateUri(uri, server_header.allocator());
	777
	778	const new_host = valid_uri.host.?.raw;
	779	const prev_host = req.uri.host.?.raw;
	780	const keep_privileged_headers =
	781	std.ascii.eqlIgnoreCase(valid_uri.scheme, req.uri.scheme) and
	782	std.ascii.endsWithIgnoreCase(new_host, prev_host) and
	783	(new_host.len == prev_host.len or new_host[new_host.len - prev_host.len - 1] == '.');
	784	if (!keep_privileged_headers) {
	785	// When redirecting to a different domain, strip privileged headers.
	786	req.privileged_headers = &.{};
	787	}
775	788
776		const port: u16 = uri.port orelse switch (protocol) {
777		.plain => 80,
778		.tls => 443,
779		};
	789	if (switch (req.response.status) {
	790	.see_other => true,
	791	.moved_permanently, .found => req.method == .POST,
	792	else => false,
	793	}) {
	794	// A redirect to a GET must change the method and remove the body.
	795	req.method = .GET;
	796	req.transfer_encoding = .none;
	797	req.headers.content_type = .omit;
	798	}
780	799
781		const host = uri.host orelse return error.UriMissingHost;
	800	if (req.transfer_encoding != .none) {
	801	// The request body has already been sent. The request is
	802	// still in a valid state, but the redirect must be handled
	803	// manually.
	804	return error.RedirectRequiresResend;
	805	}
782	806
783		req.uri = uri;
784		req.connection = try req.client.connect(host, port, protocol);
	807	req.uri = valid_uri;
	808	req.connection = try req.client.connect(new_host, valid_uri.port.?, protocol);
785	809	req.redirect_behavior.subtractOne();
786	810	req.response.parser.reset();
787	811
...	...	@@ -796,13 +820,8 @@ pub const Request = struct {
796	820
797	821	pub const SendError = Connection.WriteError \|\| error{ InvalidContentLength, UnsupportedTransferEncoding };
798	822
799		pub const SendOptions = struct {
800		/// Specifies that the uri is already escaped.
801		raw_uri: bool = false,
802		};
803
804	823	/// Send the HTTP request headers to the server.
805		pub fn send(req: *Request, options: SendOptions) SendError!void {
	824	pub fn send(req: *Request) SendError!void {
806	825	if (!req.method.requestHasBody() and req.transfer_encoding != .none)
807	826	return error.UnsupportedTransferEncoding;
808	827
...	...	@@ -821,7 +840,6 @@ pub const Request = struct {
821	840	.authority = connection.proxied,
822	841	.path = true,
823	842	.query = true,
824		.raw = options.raw_uri,
825	843	}, w);
826	844	}
827	845	try w.writeByte(' ');
...	...	@@ -1038,55 +1056,19 @@ pub const Request = struct {
1038	1056	const location = req.response.location orelse
1039	1057	return error.HttpRedirectLocationMissing;
1040	1058
1041		// This mutates the beginning of header_buffer and uses that
1042		// for the backing memory of the returned new_uri.
1043		const header_buffer = req.response.parser.header_bytes_buffer;
1044		const new_uri = req.uri.resolve_inplace(location, header_buffer) catch
1045		return error.HttpRedirectLocationInvalid;
1046
1047		// The new URI references the beginning of header_bytes_buffer memory.
1048		// That memory will be kept, but everything after it will be
1049		// reused by the subsequent request. In other words,
1050		// header_bytes_buffer must be large enough to store all
1051		// redirect locations as well as the final request header.
1052		const path_end = new_uri.path.ptr + new_uri.path.len;
1053		// https://github.com/ziglang/zig/issues/1738
1054		const path_offset = @intFromPtr(path_end) - @intFromPtr(header_buffer.ptr);
1055		const end_offset = @max(path_offset, location.len);
1056		req.response.parser.header_bytes_buffer = header_buffer[end_offset..];
1057
1058		const is_same_domain_or_subdomain =
1059		std.ascii.endsWithIgnoreCase(new_uri.host.?, req.uri.host.?) and
1060		(new_uri.host.?.len == req.uri.host.?.len or
1061		new_uri.host.?[new_uri.host.?.len - req.uri.host.?.len - 1] == '.');
1062
1063		if (new_uri.host == null or !is_same_domain_or_subdomain or
1064		!std.ascii.eqlIgnoreCase(new_uri.scheme, req.uri.scheme))
1065		{
1066		// When redirecting to a different domain, strip privileged headers.
1067		req.privileged_headers = &.{};
1068		}
1069
1070		if (switch (req.response.status) {
1071		.see_other => true,
1072		.moved_permanently, .found => req.method == .POST,
1073		else => false,
1074		}) {
1075		// A redirect to a GET must change the method and remove the body.
1076		req.method = .GET;
1077		req.transfer_encoding = .none;
1078		req.headers.content_type = .omit;
1079		}
1080
1081		if (req.transfer_encoding != .none) {
1082		// The request body has already been sent. The request is
1083		// still in a valid state, but the redirect must be handled
1084		// manually.
1085		return error.RedirectRequiresResend;
1086		}
1087
1088		try req.redirect(new_uri);
1089		try req.send(.{});
	1059	// This mutates the beginning of header_bytes_buffer and uses that
	1060	// for the backing memory of the returned Uri.
	1061	try req.redirect(req.uri.resolve_inplace(
	1062	location,
	1063	&req.response.parser.header_bytes_buffer,
	1064	) catch \|err\| switch (err) {
	1065	error.UnexpectedCharacter,
	1066	error.InvalidFormat,
	1067	error.InvalidPort,
	1068	=> return error.HttpRedirectLocationInvalid,
	1069	error.NoSpaceLeft => return error.HttpHeadersOversize,
	1070	});
	1071	try req.send();
1090	1072	} else {
1091	1073	req.response.skip = false;
1092	1074	if (!req.response.parser.done) {
...	...	@@ -1264,30 +1246,25 @@ fn createProxyFromEnvVar(arena: Allocator, env_var_names: []const []const u8) !?
1264	1246	};
1265	1247	} else return null;
1266	1248
1267		const uri = Uri.parse(content) catch try Uri.parseWithoutScheme(content);
1268
1269		const protocol = if (uri.scheme.len == 0)
1270		.plain // No scheme, assume http://
1271		else
1272		protocol_map.get(uri.scheme) orelse return null; // Unknown scheme, ignore
1273
1274		const host = uri.host orelse return error.HttpProxyMissingHost;
	1249	const uri = Uri.parse(content) catch try Uri.parseAfterScheme("http", content);
	1250	const protocol, const valid_uri = validateUri(uri, arena) catch \|err\| switch (err) {
	1251	error.UnsupportedUriScheme => return null,
	1252	error.UriMissingHost => return error.HttpProxyMissingHost,
	1253	error.OutOfMemory => \|e\| return e,
	1254	};
1275	1255
1276		const authorization: ?[]const u8 = if (uri.user != null or uri.password != null) a: {
1277		const authorization = try arena.alloc(u8, basic_authorization.valueLengthFromUri(uri));
1278		assert(basic_authorization.value(uri, authorization).len == authorization.len);
	1256	const authorization: ?[]const u8 = if (valid_uri.user != null or valid_uri.password != null) a: {
	1257	const authorization = try arena.alloc(u8, basic_authorization.valueLengthFromUri(valid_uri));
	1258	assert(basic_authorization.value(valid_uri, authorization).len == authorization.len);
1279	1259	break :a authorization;
1280	1260	} else null;
1281	1261
1282	1262	const proxy = try arena.create(Proxy);
1283	1263	proxy.* = .{
1284	1264	.protocol = protocol,
1285		.host = host,
	1265	.host = valid_uri.host.?.raw,
1286	1266	.authorization = authorization,
1287		.port = uri.port orelse switch (protocol) {
1288		.plain => 80,
1289		.tls => 443,
1290		},
	1267	.port = valid_uri.port.?,
1291	1268	.supports_connect = true,
1292	1269	};
1293	1270	return proxy;
...	...	@@ -1305,24 +1282,26 @@ pub const basic_authorization = struct {
1305	1282	}
1306	1283
1307	1284	pub fn valueLengthFromUri(uri: Uri) usize {
1308		return valueLength(
1309		if (uri.user) \|user\| user.len else 0,
1310		if (uri.password) \|password\| password.len else 0,
1311		);
	1285	var stream = std.io.countingWriter(std.io.null_writer);
	1286	try stream.writer().print("{user}", .{uri.user orelse Uri.Component.empty});
	1287	const user_len = stream.bytes_written;
	1288	stream.bytes_written = 0;
	1289	try stream.writer().print("{password}", .{uri.password orelse Uri.Component.empty});
	1290	const password_len = stream.bytes_written;
	1291	return valueLength(@intCast(user_len), @intCast(password_len));
1312	1292	}
1313	1293
1314	1294	pub fn value(uri: Uri, out: []u8) []u8 {
1315		assert(uri.user == null or uri.user.?.len <= max_user_len);
1316		assert(uri.password == null or uri.password.?.len <= max_password_len);
1317
1318		@memcpy(out[0..prefix.len], prefix);
1319
1320	1295	var buf: [max_user_len + ":".len + max_password_len]u8 = undefined;
1321		const unencoded = std.fmt.bufPrint(&buf, "{s}:{s}", .{
1322		uri.user orelse "", uri.password orelse "",
1323		}) catch unreachable;
1324		const base64 = std.base64.standard.Encoder.encode(out[prefix.len..], unencoded);
	1296	var stream = std.io.fixedBufferStream(&buf);
	1297	stream.writer().print("{user}", .{uri.user orelse Uri.Component.empty}) catch
	1298	unreachable;
	1299	assert(stream.pos <= max_user_len);
	1300	stream.writer().print(":{password}", .{uri.password orelse Uri.Component.empty}) catch
	1301	unreachable;
1325	1302
	1303	@memcpy(out[0..prefix.len], prefix);
	1304	const base64 = std.base64.standard.Encoder.encode(out[prefix.len..], stream.getWritten());
1326	1305	return out[0 .. prefix.len + base64.len];
1327	1306	}
1328	1307	};
...	...	@@ -1337,8 +1316,7 @@ pub fn connectTcp(client: *Client, host: []const u8, port: u16, protocol: Connec
1337	1316	.host = host,
1338	1317	.port = port,
1339	1318	.protocol = protocol,
1340		})) \|node\|
1341		return node;
	1319	})) \|node\| return node;
1342	1320
1343	1321	if (disable_tls and protocol == .tls)
1344	1322	return error.TlsInitializationFailed;
...	...	@@ -1449,19 +1427,12 @@ pub fn connectTunnel(
1449	1427	client.connection_pool.release(client.allocator, conn);
1450	1428	}
1451	1429
1452		const uri: Uri = .{
	1430	var buffer: [8096]u8 = undefined;
	1431	var req = client.open(.CONNECT, .{
1453	1432	.scheme = "http",
1454		.user = null,
1455		.password = null,
1456		.host = tunnel_host,
	1433	.host = .{ .raw = tunnel_host },
1457	1434	.port = tunnel_port,
1458		.path = "",
1459		.query = null,
1460		.fragment = null,
1461		};
1462
1463		var buffer: [8096]u8 = undefined;
1464		var req = client.open(.CONNECT, uri, .{
	1435	}, .{
1465	1436	.redirect_behavior = .unhandled,
1466	1437	.connection = conn,
1467	1438	.server_header_buffer = &buffer,
...	...	@@ -1471,7 +1442,7 @@ pub fn connectTunnel(
1471	1442	};
1472	1443	defer req.deinit();
1473	1444
1474		req.send(.{ .raw_uri = true }) catch \|err\| break :tunnel err;
	1445	req.send() catch \|err\| break :tunnel err;
1475	1446	req.wait() catch \|err\| break :tunnel err;
1476	1447
1477	1448	if (req.response.status.class() == .server_error) {
...	...	@@ -1500,7 +1471,7 @@ pub fn connectTunnel(
1500	1471	}
1501	1472
1502	1473	// Prevents a dependency loop in open()
1503		const ConnectErrorPartial = ConnectTcpError \|\| error{ UnsupportedUrlScheme, ConnectionRefused };
	1474	const ConnectErrorPartial = ConnectTcpError \|\| error{ UnsupportedUriScheme, ConnectionRefused };
1504	1475	pub const ConnectError = ConnectErrorPartial \|\| RequestError;
1505	1476
1506	1477	/// Connect to `host:port` using the specified protocol. This will reuse a
...	...	@@ -1548,7 +1519,7 @@ pub fn connect(
1548	1519	pub const RequestError = ConnectTcpError \|\| ConnectErrorPartial \|\| Request.SendError \|\|
1549	1520	std.fmt.ParseIntError \|\| Connection.WriteError \|\|
1550	1521	error{ // TODO: file a zig fmt issue for this bad indentation
1551		UnsupportedUrlScheme,
	1522	UnsupportedUriScheme,
1552	1523	UriMissingHost,
1553	1524
1554	1525	CertificateBundleLoadFailure,
...	...	@@ -1598,12 +1569,25 @@ pub const RequestOptions = struct {
1598	1569	privileged_headers: []const http.Header = &.{},
1599	1570	};
1600	1571
1601		pub const protocol_map = std.ComptimeStringMap(Connection.Protocol, .{
1602		.{ "http", .plain },
1603		.{ "ws", .plain },
1604		.{ "https", .tls },
1605		.{ "wss", .tls },
1606		});
	1572	fn validateUri(uri: Uri, arena: Allocator) !struct { Connection.Protocol, Uri } {
	1573	const protocol_map = std.ComptimeStringMap(Connection.Protocol, .{
	1574	.{ "http", .plain },
	1575	.{ "ws", .plain },
	1576	.{ "https", .tls },
	1577	.{ "wss", .tls },
	1578	});
	1579	const protocol = protocol_map.get(uri.scheme) orelse return error.UnsupportedUriScheme;
	1580	var valid_uri = uri;
	1581	// The host is always going to be needed as a raw string for hostname resolution anyway.
	1582	valid_uri.host = .{
	1583	.raw = try (uri.host orelse return error.UriMissingHost).toRawMaybeAlloc(arena),
	1584	};
	1585	valid_uri.port = uri.port orelse switch (protocol) {
	1586	.plain => 80,
	1587	.tls => 443,
	1588	};
	1589	return .{ protocol, valid_uri };
	1590	}
1607	1591
1608	1592	/// Open a connection to the host specified by `uri` and prepare to send a HTTP request.
1609	1593	///
...	...	@@ -1633,14 +1617,8 @@ pub fn open(
1633	1617	}
1634	1618	}
1635	1619
1636		const protocol = protocol_map.get(uri.scheme) orelse return error.UnsupportedUrlScheme;
1637
1638		const port: u16 = uri.port orelse switch (protocol) {
1639		.plain => 80,
1640		.tls => 443,
1641		};
1642
1643		const host = uri.host orelse return error.UriMissingHost;
	1620	var server_header = std.heap.FixedBufferAllocator.init(options.server_header_buffer);
	1621	const protocol, const valid_uri = try validateUri(uri, server_header.allocator());
1644	1622
1645	1623	if (protocol == .tls and @atomicLoad(bool, &client.next_https_rescan_certs, .acquire)) {
1646	1624	if (disable_tls) unreachable;
...	...	@@ -1649,15 +1627,17 @@ pub fn open(
1649	1627	defer client.ca_bundle_mutex.unlock();
1650	1628
1651	1629	if (client.next_https_rescan_certs) {
1652		client.ca_bundle.rescan(client.allocator) catch return error.CertificateBundleLoadFailure;
	1630	client.ca_bundle.rescan(client.allocator) catch
	1631	return error.CertificateBundleLoadFailure;
1653	1632	@atomicStore(bool, &client.next_https_rescan_certs, false, .release);
1654	1633	}
1655	1634	}
1656	1635
1657		const conn = options.connection orelse try client.connect(host, port, protocol);
	1636	const conn = options.connection orelse
	1637	try client.connect(valid_uri.host.?.raw, valid_uri.port.?, protocol);
1658	1638
1659	1639	var req: Request = .{
1660		.uri = uri,
	1640	.uri = valid_uri,
1661	1641	.client = client,
1662	1642	.connection = conn,
1663	1643	.keep_alive = options.keep_alive,
...	...	@@ -1671,7 +1651,7 @@ pub fn open(
1671	1651	.status = undefined,
1672	1652	.reason = undefined,
1673	1653	.keep_alive = undefined,
1674		.parser = proto.HeadersParser.init(options.server_header_buffer),
	1654	.parser = proto.HeadersParser.init(server_header.buffer[server_header.end_index..]),
1675	1655	},
1676	1656	.headers = options.headers,
1677	1657	.extra_headers = options.extra_headers,
...	...	@@ -1751,7 +1731,7 @@ pub fn fetch(client: *Client, options: FetchOptions) !FetchResult {
1751	1731
1752	1732	if (options.payload) \|payload\| req.transfer_encoding = .{ .content_length = payload.len };
1753	1733
1754		try req.send(.{ .raw_uri = options.raw_uri });
	1734	try req.send();
1755	1735
1756	1736	if (options.payload) \|payload\| try req.writeAll(payload);
1757	1737

lib/std/http/test.zig+51-21

...	...	@@ -64,7 +64,7 @@ test "trailers" {
64	64	});
65	65	defer req.deinit();
66	66
67		try req.send(.{});
	67	try req.send();
68	68	try req.wait();
69	69
70	70	const body = try req.reader().readAllAlloc(gpa, 8192);
...	...	@@ -474,6 +474,15 @@ test "general client/server API coverage" {
474	474	.{ .name = "location", .value = "/redirect/3" },
475	475	},
476	476	});
	477	} else if (mem.eql(u8, request.head.target, "/redirect/5")) {
	478	try request.respond("Hello, Redirected!\n", .{
	479	.status = .found,
	480	.extra_headers = &.{
	481	.{ .name = "location", .value = "/%2525" },
	482	},
	483	});
	484	} else if (mem.eql(u8, request.head.target, "/%2525")) {
	485	try request.respond("Encoded redirect successful!\n", .{});
477	486	} else if (mem.eql(u8, request.head.target, "/redirect/invalid")) {
478	487	const invalid_port = try getUnusedTcpPort();
479	488	const location = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}", .{invalid_port});
...	...	@@ -529,7 +538,7 @@ test "general client/server API coverage" {
529	538	});
530	539	defer req.deinit();
531	540
532		try req.send(.{});
	541	try req.send();
533	542	try req.wait();
534	543
535	544	const body = try req.reader().readAllAlloc(gpa, 8192);
...	...	@@ -554,7 +563,7 @@ test "general client/server API coverage" {
554	563	});
555	564	defer req.deinit();
556	565
557		try req.send(.{});
	566	try req.send();
558	567	try req.wait();
559	568
560	569	const body = try req.reader().readAllAlloc(gpa, 8192 * 1024);
...	...	@@ -578,7 +587,7 @@ test "general client/server API coverage" {
578	587	});
579	588	defer req.deinit();
580	589
581		try req.send(.{});
	590	try req.send();
582	591	try req.wait();
583	592
584	593	const body = try req.reader().readAllAlloc(gpa, 8192);
...	...	@@ -604,7 +613,7 @@ test "general client/server API coverage" {
604	613	});
605	614	defer req.deinit();
606	615
607		try req.send(.{});
	616	try req.send();
608	617	try req.wait();
609	618
610	619	const body = try req.reader().readAllAlloc(gpa, 8192);
...	...	@@ -629,7 +638,7 @@ test "general client/server API coverage" {
629	638	});
630	639	defer req.deinit();
631	640
632		try req.send(.{});
	641	try req.send();
633	642	try req.wait();
634	643
635	644	const body = try req.reader().readAllAlloc(gpa, 8192);
...	...	@@ -656,7 +665,7 @@ test "general client/server API coverage" {
656	665	});
657	666	defer req.deinit();
658	667
659		try req.send(.{});
	668	try req.send();
660	669	try req.wait();
661	670
662	671	const body = try req.reader().readAllAlloc(gpa, 8192);
...	...	@@ -684,7 +693,7 @@ test "general client/server API coverage" {
684	693	});
685	694	defer req.deinit();
686	695
687		try req.send(.{});
	696	try req.send();
688	697	try req.wait();
689	698
690	699	try std.testing.expectEqual(.ok, req.response.status);
...	...	@@ -725,7 +734,7 @@ test "general client/server API coverage" {
725	734	});
726	735	defer req.deinit();
727	736
728		try req.send(.{});
	737	try req.send();
729	738	try req.wait();
730	739
731	740	const body = try req.reader().readAllAlloc(gpa, 8192);
...	...	@@ -749,7 +758,7 @@ test "general client/server API coverage" {
749	758	});
750	759	defer req.deinit();
751	760
752		try req.send(.{});
	761	try req.send();
753	762	try req.wait();
754	763
755	764	const body = try req.reader().readAllAlloc(gpa, 8192);
...	...	@@ -773,7 +782,7 @@ test "general client/server API coverage" {
773	782	});
774	783	defer req.deinit();
775	784
776		try req.send(.{});
	785	try req.send();
777	786	try req.wait();
778	787
779	788	const body = try req.reader().readAllAlloc(gpa, 8192);
...	...	@@ -797,13 +806,34 @@ test "general client/server API coverage" {
797	806	});
798	807	defer req.deinit();
799	808
800		try req.send(.{});
	809	try req.send();
801	810	req.wait() catch \|err\| switch (err) {
802	811	error.TooManyHttpRedirects => {},
803	812	else => return err,
804	813	};
805	814	}
806	815
	816	{ // redirect to encoded url
	817	const location = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/redirect/5", .{port});
	818	defer gpa.free(location);
	819	const uri = try std.Uri.parse(location);
	820
	821	log.info("{s}", .{location});
	822	var server_header_buffer: [1024]u8 = undefined;
	823	var req = try client.open(.GET, uri, .{
	824	.server_header_buffer = &server_header_buffer,
	825	});
	826	defer req.deinit();
	827
	828	try req.send();
	829	try req.wait();
	830
	831	const body = try req.reader().readAllAlloc(gpa, 8192);
	832	defer gpa.free(body);
	833
	834	try expectEqualStrings("Encoded redirect successful!\n", body);
	835	}
	836
807	837	// connection has been kept alive
808	838	try expect(client.http_proxy != null or client.connection_pool.free_len == 1);
809	839
...	...	@@ -819,7 +849,7 @@ test "general client/server API coverage" {
819	849	});
820	850	defer req.deinit();
821	851
822		try req.send(.{});
	852	try req.send();
823	853	const result = req.wait();
824	854
825	855	// a proxy without an upstream is likely to return a 5xx status.
...	...	@@ -913,16 +943,16 @@ test "Server streams both reading and writing" {
913	943	var server_header_buffer: [555]u8 = undefined;
914	944	var req = try client.open(.POST, .{
915	945	.scheme = "http",
916		.host = "127.0.0.1",
	946	.host = .{ .raw = "127.0.0.1" },
917	947	.port = test_server.port(),
918		.path = "/",
	948	.path = .{ .percent_encoded = "/" },
919	949	}, .{
920	950	.server_header_buffer = &server_header_buffer,
921	951	});
922	952	defer req.deinit();
923	953
924	954	req.transfer_encoding = .chunked;
925		try req.send(.{});
	955	try req.send();
926	956	try req.wait();
927	957
928	958	try req.writeAll("one ");
...	...	@@ -956,7 +986,7 @@ fn echoTests(client: *http.Client, port: u16) !void {
956	986
957	987	req.transfer_encoding = .{ .content_length = 14 };
958	988
959		try req.send(.{});
	989	try req.send();
960	990	try req.writeAll("Hello, ");
961	991	try req.writeAll("World!\n");
962	992	try req.finish();
...	...	@@ -990,7 +1020,7 @@ fn echoTests(client: *http.Client, port: u16) !void {
990	1020
991	1021	req.transfer_encoding = .chunked;
992	1022
993		try req.send(.{});
	1023	try req.send();
994	1024	try req.writeAll("Hello, ");
995	1025	try req.writeAll("World!\n");
996	1026	try req.finish();
...	...	@@ -1044,7 +1074,7 @@ fn echoTests(client: *http.Client, port: u16) !void {
1044	1074
1045	1075	req.transfer_encoding = .chunked;
1046	1076
1047		try req.send(.{});
	1077	try req.send();
1048	1078	try req.writeAll("Hello, ");
1049	1079	try req.writeAll("World!\n");
1050	1080	try req.finish();
...	...	@@ -1075,7 +1105,7 @@ fn echoTests(client: *http.Client, port: u16) !void {
1075	1105
1076	1106	req.transfer_encoding = .chunked;
1077	1107
1078		try req.send(.{});
	1108	try req.send();
1079	1109	try req.wait();
1080	1110	try expectEqual(.expectation_failed, req.response.status);
1081	1111	}
...	...	@@ -1180,7 +1210,7 @@ test "redirect to different connection" {
1180	1210	});
1181	1211	defer req.deinit();
1182	1212
1183		try req.send(.{});
	1213	try req.send();
1184	1214	try req.wait();
1185	1215
1186	1216	const body = try req.reader().readAllAlloc(gpa, 8192);

lib/std/io.zig+1-1

...	...	@@ -413,7 +413,7 @@ pub const StreamSource = @import("io/stream_source.zig").StreamSource;
413	413	pub const tty = @import("io/tty.zig");
414	414
415	415	/// A Writer that doesn't write to anything.
416		pub const null_writer = @as(NullWriter, .{ .context = {} });
	416	pub const null_writer: NullWriter = .{ .context = {} };
417	417
418	418	const NullWriter = Writer(void, error{}, dummyWrite);
419	419	fn dummyWrite(context: void, data: []const u8) error{}!usize {

src/Package/Fetch.zig+13-11

...	...	@@ -339,12 +339,12 @@ pub fn run(f: *Fetch) RunError!void {
339	339	.path_or_url => \|path_or_url\| {
340	340	if (fs.cwd().openDir(path_or_url, .{ .iterate = true })) \|dir\| {
341	341	var resource: Resource = .{ .dir = dir };
342		return runResource(f, path_or_url, &resource, null);
	342	return f.runResource(path_or_url, &resource, null);
343	343	} else \|dir_err\| {
344	344	const file_err = if (dir_err == error.NotDir) e: {
345	345	if (fs.cwd().openFile(path_or_url, .{})) \|file\| {
346	346	var resource: Resource = .{ .file = file };
347		return runResource(f, path_or_url, &resource, null);
	347	return f.runResource(path_or_url, &resource, null);
348	348	} else \|err\| break :e err;
349	349	} else dir_err;
350	350
...	...	@@ -356,7 +356,7 @@ pub fn run(f: *Fetch) RunError!void {
356	356	};
357	357	var server_header_buffer: [header_buffer_size]u8 = undefined;
358	358	var resource = try f.initResource(uri, &server_header_buffer);
359		return runResource(f, uri.path, &resource, null);
	359	return f.runResource(try uri.path.toRawMaybeAlloc(arena), &resource, null);
360	360	}
361	361	},
362	362	};
...	...	@@ -418,7 +418,7 @@ pub fn run(f: *Fetch) RunError!void {
418	418	);
419	419	var server_header_buffer: [header_buffer_size]u8 = undefined;
420	420	var resource = try f.initResource(uri, &server_header_buffer);
421		return runResource(f, uri.path, &resource, remote.hash);
	421	return f.runResource(try uri.path.toRawMaybeAlloc(arena), &resource, remote.hash);
422	422	}
423	423
424	424	pub fn deinit(f: *Fetch) void {
...	...	@@ -897,13 +897,14 @@ fn initResource(f: *Fetch, uri: std.Uri, server_header_buffer: []u8) RunError!Re
897	897	const arena = f.arena.allocator();
898	898	const eb = &f.error_bundle;
899	899
900		if (ascii.eqlIgnoreCase(uri.scheme, "file")) return .{
901		.file = f.parent_package_root.openFile(uri.path, .{}) catch \|err\| {
	900	if (ascii.eqlIgnoreCase(uri.scheme, "file")) {
	901	const path = try uri.path.toRawMaybeAlloc(arena);
	902	return .{ .file = f.parent_package_root.openFile(path, .{}) catch \|err\| {
902	903	return f.fail(f.location_tok, try eb.printString("unable to open '{}{s}': {s}", .{
903		f.parent_package_root, uri.path, @errorName(err),
	904	f.parent_package_root, path, @errorName(err),
904	905	}));
905		},
906		};
	906	} };
	907	}
907	908
908	909	const http_client = f.job_queue.http_client;
909	910
...	...	@@ -920,7 +921,7 @@ fn initResource(f: *Fetch, uri: std.Uri, server_header_buffer: []u8) RunError!Re
920	921	};
921	922	errdefer req.deinit(); // releases more than memory
922	923
923		req.send(.{}) catch \|err\| {
	924	req.send() catch \|err\| {
924	925	return f.fail(f.location_tok, try eb.printString(
925	926	"HTTP request failed: {s}",
926	927	.{@errorName(err)},
...	...	@@ -967,7 +968,8 @@ fn initResource(f: *Fetch, uri: std.Uri, server_header_buffer: []u8) RunError!Re
967	968	};
968	969
969	970	const want_oid = want_oid: {
970		const want_ref = uri.fragment orelse "HEAD";
	971	const want_ref =
	972	if (uri.fragment) \|fragment\| try fragment.toRawMaybeAlloc(arena) else "HEAD";
971	973	if (git.parseOid(want_ref)) \|oid\| break :want_oid oid else \|_\| {}
972	974
973	975	const want_ref_head = try std.fmt.allocPrint(arena, "refs/heads/{s}", .{want_ref});

src/Package/Fetch/git.zig+26-12

...	...	@@ -540,9 +540,13 @@ pub const Session = struct {
540	540	http_headers_buffer: []u8,
541	541	) !CapabilityIterator {
542	542	var info_refs_uri = session.uri;
543		info_refs_uri.path = try std.fs.path.resolvePosix(allocator, &.{ "/", session.uri.path, "info/refs" });
544		defer allocator.free(info_refs_uri.path);
545		info_refs_uri.query = "service=git-upload-pack";
	543	{
	544	const session_uri_path = try std.fmt.allocPrint(allocator, "{path}", .{session.uri.path});
	545	defer allocator.free(session_uri_path);
	546	info_refs_uri.path = .{ .percent_encoded = try std.fs.path.resolvePosix(allocator, &.{ "/", session_uri_path, "info/refs" }) };
	547	}
	548	defer allocator.free(info_refs_uri.path.percent_encoded);
	549	info_refs_uri.query = .{ .percent_encoded = "service=git-upload-pack" };
546	550	info_refs_uri.fragment = null;
547	551
548	552	const max_redirects = 3;
...	...	@@ -554,16 +558,18 @@ pub const Session = struct {
554	558	},
555	559	});
556	560	errdefer request.deinit();
557		try request.send(.{});
	561	try request.send();
558	562	try request.finish();
559	563
560	564	try request.wait();
561	565	if (request.response.status != .ok) return error.ProtocolError;
562	566	const any_redirects_occurred = request.redirect_behavior.remaining() < max_redirects;
563	567	if (any_redirects_occurred) {
564		if (!mem.endsWith(u8, request.uri.path, "/info/refs")) return error.UnparseableRedirect;
	568	const request_uri_path = try std.fmt.allocPrint(allocator, "{path}", .{request.uri.path});
	569	defer allocator.free(request_uri_path);
	570	if (!mem.endsWith(u8, request_uri_path, "/info/refs")) return error.UnparseableRedirect;
565	571	var new_uri = request.uri;
566		new_uri.path = new_uri.path[0 .. new_uri.path.len - "/info/refs".len];
	572	new_uri.path = .{ .percent_encoded = request_uri_path[0 .. request_uri_path.len - "/info/refs".len] };
567	573	new_uri.query = null;
568	574	redirect_uri.* = try std.fmt.allocPrint(allocator, "{+/}", .{new_uri});
569	575	return error.Redirected;
...	...	@@ -645,8 +651,12 @@ pub const Session = struct {
645	651	/// Returns an iterator over refs known to the server.
646	652	pub fn listRefs(session: Session, allocator: Allocator, options: ListRefsOptions) !RefIterator {
647	653	var upload_pack_uri = session.uri;
648		upload_pack_uri.path = try std.fs.path.resolvePosix(allocator, &.{ "/", session.uri.path, "git-upload-pack" });
649		defer allocator.free(upload_pack_uri.path);
	654	{
	655	const session_uri_path = try std.fmt.allocPrint(allocator, "{path}", .{session.uri.path});
	656	defer allocator.free(session_uri_path);
	657	upload_pack_uri.path = .{ .percent_encoded = try std.fs.path.resolvePosix(allocator, &.{ "/", session_uri_path, "git-upload-pack" }) };
	658	}
	659	defer allocator.free(upload_pack_uri.path.percent_encoded);
650	660	upload_pack_uri.query = null;
651	661	upload_pack_uri.fragment = null;
652	662
...	...	@@ -681,7 +691,7 @@ pub const Session = struct {
681	691	});
682	692	errdefer request.deinit();
683	693	request.transfer_encoding = .{ .content_length = body.items.len };
684		try request.send(.{});
	694	try request.send();
685	695	try request.writeAll(body.items);
686	696	try request.finish();
687	697
...	...	@@ -748,8 +758,12 @@ pub const Session = struct {
748	758	http_headers_buffer: []u8,
749	759	) !FetchStream {
750	760	var upload_pack_uri = session.uri;
751		upload_pack_uri.path = try std.fs.path.resolvePosix(allocator, &.{ "/", session.uri.path, "git-upload-pack" });
752		defer allocator.free(upload_pack_uri.path);
	761	{
	762	const session_uri_path = try std.fmt.allocPrint(allocator, "{path}", .{session.uri.path});
	763	defer allocator.free(session_uri_path);
	764	upload_pack_uri.path = .{ .percent_encoded = try std.fs.path.resolvePosix(allocator, &.{ "/", session_uri_path, "git-upload-pack" }) };
	765	}
	766	defer allocator.free(upload_pack_uri.path.percent_encoded);
753	767	upload_pack_uri.query = null;
754	768	upload_pack_uri.fragment = null;
755	769
...	...	@@ -786,7 +800,7 @@ pub const Session = struct {
786	800	});
787	801	errdefer request.deinit();
788	802	request.transfer_encoding = .{ .content_length = body.items.len };
789		try request.send(.{});
	803	try request.send();
790	804	try request.writeAll(body.items);
791	805	try request.finish();
792	806

src/link/SpirV.zig+12-3

...	...	@@ -233,9 +233,18 @@ pub fn flushModule(self: SpirV, arena: Allocator, prog_node: std.Progress.Node
233	233	// name if it contains no strange characters is nice for debugging. URI encoding fits the bill.
234	234	// We're using : as separator, which is a reserved character.
235	235
236		const escaped_name = try std.Uri.escapeString(gpa, name.toSlice(&mod.intern_pool));
237		defer gpa.free(escaped_name);
238		try error_info.writer().print(":{s}", .{escaped_name});
	236	try std.Uri.Component.percentEncode(
	237	error_info.writer(),
	238	name.toSlice(&mod.intern_pool),
	239	struct {
	240	fn isValidChar(c: u8) bool {
	241	return switch (c) {
	242	0, '%', ':' => false,
	243	else => true,
	244	};
	245	}
	246	}.isValidChar,
	247	);
239	248	}
240	249	try spv.sections.debug_strings.emit(gpa, .OpSourceExtension, .{
241	250	.extension = error_info.items,