Commit a111f805cd6cc82952786d0ffccb5a31c68f6353 | zig

author	Jacob Young <jacobly@ziglang.org> 2024-01-31 14:44:34+01:00
committer	Jacob Young <jacobly@ziglang.org> 2024-01-31 15:00:27+01:00
log	a111f805cd6cc82952786d0ffccb5a31c68f6353
tree	a0dfe75cebdeaab9a4cb8c9b6c6a54022c5c8f9b
parent	82b37ea0240c0e77857149d80beb4dda2b095dbb

http: avoid allocator use when encoding basic authorization

1 files changed, 45 insertions(+), 23 deletions(-)

lib
- std
  - http
    Client.zig

lib/std/http/Client.zig+45-23

 @@ -339,7 +339,7 @@ pub const Connection = struct {
     /// Writes the given buffer to the connection.
     pub fn write(conn: *Connection, buffer: []const u8) WriteError!usize {
-        if (conn.write_end + buffer.len > conn.write_buf.len) {
+        if (conn.write_buf.len - conn.write_end < buffer.len) {
             try conn.flush();
             if (buffer.len > conn.write_buf.len) {
 @@ -354,6 +354,13 @@ pub const Connection = struct {
         return buffer.len;
     }
+    /// Returns a buffer to be filled with exactly len bytes to write to the connection.
+    pub fn allocWriteBuffer(conn: *Connection, len: BufferSize) WriteError![]u8 {
+        if (conn.write_buf.len - conn.write_end < len) try conn.flush();
+        defer conn.write_end += len;
+        return conn.write_buf[conn.write_end..][0..len];
+    }
     /// Flushes the write buffer to the connection.
     pub fn flush(conn: *Connection) WriteError!void {
         if (conn.write_end == 0) return;
 @@ -657,7 +664,7 @@ pub const Request = struct {
         };
     }
-    pub const SendError = Allocator.Error || Connection.WriteError || error{ InvalidContentLength, UnsupportedTransferEncoding };
+    pub const SendError = Connection.WriteError || error{ InvalidContentLength, UnsupportedTransferEncoding };
     pub const SendOptions = struct {
         /// Specifies that the uri should be used as is. You guarantee that the uri is already escaped.
 @@ -699,7 +706,10 @@ pub const Request = struct {
             !req.headers.contains("authorization"))
         {
             try w.writeAll("Authorization: ");
-            try w.writeAll(try basicAuthorizationValue(req.arena.allocator(), req.uri));
+            const authorization = try req.connection.?.allocWriteBuffer(
+                @intCast(basic_authorization.valueLengthFromUri(req.uri)),
+            );
+            std.debug.assert(basic_authorization.value(req.uri, authorization).len == authorization.len);
             try w.writeAll("\r\n");
         }
 @@ -1131,10 +1141,8 @@ pub fn loadDefaultProxies(client: *Client) !void {
         };
         if (uri.user != null or uri.password != null) {
-            const authorization = try basicAuthorizationValue(client.allocator, uri);
+            var authorization: [basic_authorization.max_value_len]u8 = undefined;
-            defer client.allocator.free(authorization);
+            try client.http_proxy.?.headers.append("proxy-authorization", basic_authorization.value(uri, &authorization));
-            try client.http_proxy.?.headers.append("proxy-authorization", authorization);
         }
     }
 @@ -1174,31 +1182,45 @@ pub fn loadDefaultProxies(client: *Client) !void {
         };
         if (uri.user != null or uri.password != null) {
-            const authorization = try basicAuthorizationValue(client.allocator, uri);
+            var authorization: [basic_authorization.max_value_len]u8 = undefined;
-            defer client.allocator.free(authorization);
+            try client.https_proxy.?.headers.append("proxy-authorization", basic_authorization.value(uri, &authorization));
-            try client.https_proxy.?.headers.append("proxy-authorization", authorization);
         }
     }
 }
-pub fn basicAuthorizationValue(
+pub const basic_authorization = struct {
-    allocator: Allocator,
+    pub const max_user_len = 255;
-    uri: Uri,
+    pub const max_password_len = 255;
-) Allocator.Error![]const u8 {
+    pub const max_value_len = valueLength(max_user_len, max_password_len);
     const prefix = "Basic ";
-    const unencoded = try std.fmt.allocPrint(allocator, "{s}:{s}", .{ uri.user orelse "", uri.password orelse "" });
+    pub fn valueLength(user_len: usize, password_len: usize) usize {
-    defer allocator.free(unencoded);
+        return prefix.len + std.base64.standard.Encoder.calcSize(user_len + 1 + password_len);
+    }
+    pub fn valueLengthFromUri(uri: Uri) usize {
+        return valueLength(
+            if (uri.user) |user| user.len else 0,
+            if (uri.password) |password| password.len else 0,
+        );
+    }
-    const buffer = try allocator.alloc(u8, prefix.len + std.base64.standard.Encoder.calcSize(unencoded.len));
+    pub fn value(uri: Uri, out: []u8) []u8 {
-    errdefer allocator.free(buffer);
+        std.debug.assert(uri.user == null or uri.user.?.len <= max_user_len);
+        std.debug.assert(uri.password == null or uri.password.?.len <= max_password_len);
-    @memcpy(buffer[0..prefix.len], prefix);
+        @memcpy(out[0..prefix.len], prefix);
-    _ = std.base64.standard.Encoder.encode(buffer[prefix.len..], unencoded);
-    return buffer;
+        var buf: [max_user_len + ":".len + max_password_len]u8 = undefined;
-}
+        const unencoded = std.fmt.bufPrint(&buf, "{s}:{s}", .{
+            uri.user orelse "", uri.password orelse "",
+        }) catch unreachable;
+        const base64 = std.base64.standard.Encoder.encode(out[prefix.len..], unencoded);
+        return out[0 .. prefix.len + base64.len];
+    }
+};
 pub const ConnectTcpError = Allocator.Error || error{ ConnectionRefused, NetworkUnreachable, ConnectionTimedOut, ConnectionResetByPeer, TemporaryNameServerFailure, NameServerFailure, UnknownHostName, HostLacksNetworkAddresses, UnexpectedConnectFailure, TlsInitializationFailed };