aboutsummaryrefslogtreecommitdiff
path: root/vendor/libghostty-vt/src/terminal/kitty
diff options
context:
space:
mode:
authorOgulcan Celik <ogulcancelik@gmail.com>2026-05-07 18:29:21 +0300
committerOgulcan Celik <ogulcancelik@gmail.com>2026-05-07 18:29:21 +0300
commitdcfe11a7588fcd42471159453810abc9b7720a57 (patch)
treec32a77266028e73ca2382b96c96f8438a5fcd621 /vendor/libghostty-vt/src/terminal/kitty
parent2dfed860103c4e4505ac7f25def9fe37da1e1e6a (diff)
build: update libghostty-vt vendor
vendor ghostty 063ac3e and remove the musl libc++ link workaround. expose the new selection formatter and hyperlink uri apis for follow-up rendering work. add manual artifact validation for static linux builds.
Diffstat (limited to 'vendor/libghostty-vt/src/terminal/kitty')
-rw-r--r--vendor/libghostty-vt/src/terminal/kitty/graphics.zig1
-rw-r--r--vendor/libghostty-vt/src/terminal/kitty/graphics_command.zig114
-rw-r--r--vendor/libghostty-vt/src/terminal/kitty/graphics_exec.zig13
-rw-r--r--vendor/libghostty-vt/src/terminal/kitty/graphics_image.zig271
-rw-r--r--vendor/libghostty-vt/src/terminal/kitty/graphics_storage.zig19
5 files changed, 323 insertions, 95 deletions
diff --git a/vendor/libghostty-vt/src/terminal/kitty/graphics.zig b/vendor/libghostty-vt/src/terminal/kitty/graphics.zig
index c710f81a..6659cd31 100644
--- a/vendor/libghostty-vt/src/terminal/kitty/graphics.zig
+++ b/vendor/libghostty-vt/src/terminal/kitty/graphics.zig
@@ -25,6 +25,7 @@ pub const unicode = @import("graphics_unicode.zig");
pub const Command = command.Command;
pub const CommandParser = command.Parser;
pub const Image = image.Image;
+pub const LoadingImage = image.LoadingImage;
pub const ImageStorage = storage.ImageStorage;
pub const RenderPlacement = render.Placement;
pub const Response = command.Response;
diff --git a/vendor/libghostty-vt/src/terminal/kitty/graphics_command.zig b/vendor/libghostty-vt/src/terminal/kitty/graphics_command.zig
index dfce56e3..aa35fbeb 100644
--- a/vendor/libghostty-vt/src/terminal/kitty/graphics_command.zig
+++ b/vendor/libghostty-vt/src/terminal/kitty/graphics_command.zig
@@ -3,6 +3,7 @@ const assert = @import("../../quirks.zig").inlineAssert;
const Allocator = std.mem.Allocator;
const ArenaAllocator = std.heap.ArenaAllocator;
const simd = @import("../../simd/main.zig");
+const lib = @import("../lib.zig");
const log = std.log.scoped(.kitty_gfx);
@@ -37,6 +38,10 @@ pub const Parser = struct {
/// here instead of a fixed buffer so that we can too.
data: std.ArrayList(u8),
+ /// Maximum bytes the data payload can take. This is to prevent
+ /// malicious input from causing us to allocate too much memory.
+ max_bytes: usize,
+
/// Internal state for parsing.
state: State,
@@ -54,7 +59,7 @@ pub const Parser = struct {
/// Initialize the parser. The allocator given will be used for both
/// temporary data and long-lived values such as the final image blob.
- pub fn init(alloc: Allocator) Parser {
+ pub fn init(alloc: Allocator, max_bytes: usize) Parser {
var arena = ArenaAllocator.init(alloc);
errdefer arena.deinit();
var result: Parser = .{
@@ -63,6 +68,7 @@ pub const Parser = struct {
.kv = .{},
.kv_temp_len = 0,
.kv_current = 0,
+ .max_bytes = max_bytes,
.state = .control_key,
.kv_temp = undefined,
@@ -83,7 +89,7 @@ pub const Parser = struct {
/// Parse a complete command string.
pub fn parseString(alloc: Allocator, data: []const u8) !Command {
- var parser = init(alloc);
+ var parser = init(alloc, 1024 * 1024);
defer parser.deinit();
for (data) |c| try parser.feed(c);
return try parser.complete(alloc);
@@ -136,7 +142,10 @@ pub const Parser = struct {
else => {},
},
- .data => try self.data.append(self.arena.child_allocator, c),
+ .data => {
+ if (self.data.items.len >= self.max_bytes) return error.OutOfMemory;
+ try self.data.append(self.arena.child_allocator, c);
+ },
}
}
@@ -394,39 +403,38 @@ pub const Transmission = struct {
compression: Compression = .none, // o
more_chunks: bool = false, // m
- pub const Format = enum {
- rgb, // 24
- rgba, // 32
- png, // 100
-
+ pub const Format = lib.Enum(lib.target, &.{
+ "rgb", // 24
+ "rgba", // 32
+ "png", // 100
// The following are not supported directly via the protocol
// but they are formats that a png may decode to that we
// support.
- gray_alpha,
- gray,
-
- pub fn bpp(self: Format) u8 {
- return switch (self) {
- .gray => 1,
- .gray_alpha => 2,
- .rgb => 3,
- .rgba => 4,
- .png => unreachable, // Must be validated before
- };
- }
- };
-
- pub const Medium = enum {
- direct, // d
- file, // f
- temporary_file, // t
- shared_memory, // s
- };
-
- pub const Compression = enum {
- none,
- zlib_deflate, // z
- };
+ "gray_alpha",
+ "gray",
+ });
+
+ pub const Medium = lib.Enum(lib.target, &.{
+ "direct", // d
+ "file", // f
+ "temporary_file", // t
+ "shared_memory", // s
+ });
+
+ pub const Compression = lib.Enum(lib.target, &.{
+ "none",
+ "zlib_deflate", // z
+ });
+
+ pub fn formatBpp(format: Format) u8 {
+ return switch (format) {
+ .gray => 1,
+ .gray_alpha => 2,
+ .rgb => 3,
+ .rgba => 4,
+ .png => unreachable, // Must be validated before
+ };
+ }
fn parse(kv: KV) !Transmission {
var result: Transmission = .{};
@@ -964,7 +972,7 @@ pub const CompositionMode = enum {
test "transmission command" {
const testing = std.testing;
const alloc = testing.allocator;
- var p = Parser.init(alloc);
+ var p = Parser.init(alloc, 1024 * 1024);
defer p.deinit();
const input = "f=24,s=10,v=20";
@@ -982,7 +990,7 @@ test "transmission command" {
test "transmission ignores 'm' if medium is not direct" {
const testing = std.testing;
const alloc = testing.allocator;
- var p = Parser.init(alloc);
+ var p = Parser.init(alloc, 1024 * 1024);
defer p.deinit();
const input = "a=t,t=t,m=1";
@@ -999,7 +1007,7 @@ test "transmission ignores 'm' if medium is not direct" {
test "transmission respects 'm' if medium is direct" {
const testing = std.testing;
const alloc = testing.allocator;
- var p = Parser.init(alloc);
+ var p = Parser.init(alloc, 1024 * 1024);
defer p.deinit();
const input = "a=t,t=d,m=1";
@@ -1016,7 +1024,7 @@ test "transmission respects 'm' if medium is direct" {
test "query command" {
const testing = std.testing;
const alloc = testing.allocator;
- var p = Parser.init(alloc);
+ var p = Parser.init(alloc, 1024 * 1024);
defer p.deinit();
const input = "i=31,s=1,v=1,a=q,t=d,f=24;QUFBQQ";
@@ -1036,7 +1044,7 @@ test "query command" {
test "display command" {
const testing = std.testing;
const alloc = testing.allocator;
- var p = Parser.init(alloc);
+ var p = Parser.init(alloc, 1024 * 1024);
defer p.deinit();
const input = "a=p,U=1,i=31,c=80,r=120";
@@ -1054,7 +1062,7 @@ test "display command" {
test "delete command" {
const testing = std.testing;
const alloc = testing.allocator;
- var p = Parser.init(alloc);
+ var p = Parser.init(alloc, 1024 * 1024);
defer p.deinit();
const input = "a=d,d=p,x=3,y=4";
@@ -1074,7 +1082,7 @@ test "delete command" {
test "no control data" {
const testing = std.testing;
const alloc = testing.allocator;
- var p = Parser.init(alloc);
+ var p = Parser.init(alloc, 1024 * 1024);
defer p.deinit();
const input = ";QUFBQQ";
@@ -1089,7 +1097,7 @@ test "no control data" {
test "ignore unknown keys (long)" {
const testing = std.testing;
const alloc = testing.allocator;
- var p = Parser.init(alloc);
+ var p = Parser.init(alloc, 1024 * 1024);
defer p.deinit();
const input = "f=24,s=10,v=20,hello=world";
@@ -1107,7 +1115,7 @@ test "ignore unknown keys (long)" {
test "ignore very long values" {
const testing = std.testing;
const alloc = testing.allocator;
- var p = Parser.init(alloc);
+ var p = Parser.init(alloc, 1024 * 1024);
defer p.deinit();
const input = "f=24,s=10,v=2000000000000000000000000000000000000000";
@@ -1125,7 +1133,7 @@ test "ignore very long values" {
test "ensure very large negative values don't get skipped" {
const testing = std.testing;
const alloc = testing.allocator;
- var p = Parser.init(alloc);
+ var p = Parser.init(alloc, 1024 * 1024);
defer p.deinit();
const input = "a=p,i=1,z=-2000000000";
@@ -1142,7 +1150,7 @@ test "ensure very large negative values don't get skipped" {
test "ensure proper overflow error for u32" {
const testing = std.testing;
const alloc = testing.allocator;
- var p = Parser.init(alloc);
+ var p = Parser.init(alloc, 1024 * 1024);
defer p.deinit();
const input = "a=p,i=10000000000";
@@ -1153,7 +1161,7 @@ test "ensure proper overflow error for u32" {
test "ensure proper overflow error for i32" {
const testing = std.testing;
const alloc = testing.allocator;
- var p = Parser.init(alloc);
+ var p = Parser.init(alloc, 1024 * 1024);
defer p.deinit();
const input = "a=p,i=1,z=-9999999999";
@@ -1167,7 +1175,7 @@ test "all i32 values" {
{
// 'z' (usually z-axis values)
- var p = Parser.init(alloc);
+ var p = Parser.init(alloc, 1024 * 1024);
defer p.deinit();
const input = "a=p,i=1,z=-1";
for (input) |c| try p.feed(c);
@@ -1182,7 +1190,7 @@ test "all i32 values" {
{
// 'H' (relative placement, horizontal offset)
- var p = Parser.init(alloc);
+ var p = Parser.init(alloc, 1024 * 1024);
defer p.deinit();
const input = "a=p,i=1,H=-1";
for (input) |c| try p.feed(c);
@@ -1197,7 +1205,7 @@ test "all i32 values" {
{
// 'V' (relative placement, vertical offset)
- var p = Parser.init(alloc);
+ var p = Parser.init(alloc, 1024 * 1024);
defer p.deinit();
const input = "a=p,i=1,V=-1";
for (input) |c| try p.feed(c);
@@ -1254,7 +1262,7 @@ test "response: encode with image ID and number" {
test "delete range command 1" {
const testing = std.testing;
const alloc = testing.allocator;
- var p = Parser.init(alloc);
+ var p = Parser.init(alloc, 1024 * 1024);
defer p.deinit();
const input = "a=d,d=r,x=3,y=4";
@@ -1274,7 +1282,7 @@ test "delete range command 1" {
test "delete range command 2" {
const testing = std.testing;
const alloc = testing.allocator;
- var p = Parser.init(alloc);
+ var p = Parser.init(alloc, 1024 * 1024);
defer p.deinit();
const input = "a=d,d=R,x=5,y=11";
@@ -1294,7 +1302,7 @@ test "delete range command 2" {
test "delete range command 3" {
const testing = std.testing;
const alloc = testing.allocator;
- var p = Parser.init(alloc);
+ var p = Parser.init(alloc, 1024 * 1024);
defer p.deinit();
const input = "a=d,d=R,x=5,y=4";
@@ -1305,7 +1313,7 @@ test "delete range command 3" {
test "delete range command 4" {
const testing = std.testing;
const alloc = testing.allocator;
- var p = Parser.init(alloc);
+ var p = Parser.init(alloc, 1024 * 1024);
defer p.deinit();
const input = "a=d,d=R,x=5";
@@ -1316,7 +1324,7 @@ test "delete range command 4" {
test "delete range command 5" {
const testing = std.testing;
const alloc = testing.allocator;
- var p = Parser.init(alloc);
+ var p = Parser.init(alloc, 1024 * 1024);
defer p.deinit();
const input = "a=d,d=R,y=5";
diff --git a/vendor/libghostty-vt/src/terminal/kitty/graphics_exec.zig b/vendor/libghostty-vt/src/terminal/kitty/graphics_exec.zig
index 5b3ab915..a6a879e5 100644
--- a/vendor/libghostty-vt/src/terminal/kitty/graphics_exec.zig
+++ b/vendor/libghostty-vt/src/terminal/kitty/graphics_exec.zig
@@ -44,7 +44,7 @@ pub fn execute(
var quiet = cmd.quiet;
const resp_: ?Response = switch (cmd.control) {
- .query => query(alloc, cmd),
+ .query => query(alloc, terminal, cmd),
.display => display(alloc, terminal, cmd),
.delete => delete(alloc, terminal, cmd),
@@ -94,7 +94,11 @@ pub fn execute(
/// This command is used to attempt to load an image and respond with
/// success/error but does not persist any of the command to the terminal
/// state.
-fn query(alloc: Allocator, cmd: *const Command) Response {
+fn query(
+ alloc: Allocator,
+ terminal: *const Terminal,
+ cmd: *const Command,
+) Response {
const t = cmd.control.query;
// Query requires image ID. We can't actually send a response without
@@ -112,7 +116,8 @@ fn query(alloc: Allocator, cmd: *const Command) Response {
};
// Attempt to load the image. If we cannot, then set an appropriate error.
- var loading = LoadingImage.init(alloc, cmd) catch |err| {
+ const storage = &terminal.screens.active.kitty_images;
+ var loading = LoadingImage.init(alloc, cmd, storage.image_limits) catch |err| {
encodeError(&result, err);
return result;
};
@@ -322,7 +327,7 @@ fn loadAndAddImage(
}
break :loading loading.*;
- } else try .init(alloc, cmd);
+ } else try .init(alloc, cmd, storage.image_limits);
// We only want to deinit on error. If we're chunking, then we don't
// want to deinit at all. If we're not chunking, then we'll deinit
diff --git a/vendor/libghostty-vt/src/terminal/kitty/graphics_image.zig b/vendor/libghostty-vt/src/terminal/kitty/graphics_image.zig
index d2877cfc..8243a632 100644
--- a/vendor/libghostty-vt/src/terminal/kitty/graphics_image.zig
+++ b/vendor/libghostty-vt/src/terminal/kitty/graphics_image.zig
@@ -8,7 +8,7 @@ const posix = std.posix;
const fastmem = @import("../../fastmem.zig");
const command = @import("graphics_command.zig");
const PageList = @import("../PageList.zig");
-const wuffs = @import("wuffs");
+const sys = @import("../sys.zig");
const temp_dir = struct {
const TempDir = @import("../../os/TempDir.zig");
@@ -44,10 +44,38 @@ pub const LoadingImage = struct {
/// used if q isn't set on subsequent chunks.
quiet: command.Command.Quiet,
+ /// The limits of the Kitty Graphics protocol we should allow.
+ ///
+ /// This can be used to restrict the type of images and other
+ /// parameters for resource or security reasons. Note that depending
+ /// on how libghostty is compiled, some of these may be fully unsupported
+ /// and ignored (e.g. "file" on wasm32-freestanding).
+ pub const Limits = packed struct {
+ file: bool,
+ temporary_file: bool,
+ shared_memory: bool,
+
+ pub const all: Limits = .{
+ .file = true,
+ .temporary_file = true,
+ .shared_memory = true,
+ };
+
+ pub const direct: Limits = .{
+ .file = false,
+ .temporary_file = false,
+ .shared_memory = false,
+ };
+ };
+
/// Initialize a chunked immage from the first image transmission.
/// If this is a multi-chunk image, this should only be the FIRST
/// chunk.
- pub fn init(alloc: Allocator, cmd: *const command.Command) !LoadingImage {
+ pub fn init(
+ alloc: Allocator,
+ cmd: *const command.Command,
+ limits: Limits,
+ ) !LoadingImage {
// Build our initial image from the properties sent via the control.
// These can be overwritten by the data loading process. For example,
// PNG loading sets the width/height from the data.
@@ -72,6 +100,26 @@ pub const LoadingImage = struct {
return result;
}
+ // Verify our capabilities and limits allow this.
+ {
+ // Special case if we don't support decoding PNGs and the format
+ // is a PNG we can save a lot of memory/effort buffering the
+ // data but failing up front.
+ if (t.format == .png and
+ sys.decode_png == null)
+ {
+ return error.UnsupportedMedium;
+ }
+
+ // Verify the medium is allowed
+ switch (t.medium) {
+ .direct => unreachable,
+ .file => if (!limits.file) return error.UnsupportedMedium,
+ .temporary_file => if (!limits.temporary_file) return error.UnsupportedMedium,
+ .shared_memory => if (!limits.shared_memory) return error.UnsupportedMedium,
+ }
+ }
+
// Otherwise, the payload data is guaranteed to be a path.
if (comptime builtin.os.tag != .windows) {
@@ -111,8 +159,9 @@ pub const LoadingImage = struct {
t: command.Transmission,
path: []const u8,
) !void {
+ // android does not support POSIX shared memory.
// windows is currently unsupported, does it support shm?
- if (comptime builtin.target.os.tag == .windows) {
+ if (comptime builtin.abi.isAndroid() or builtin.target.os.tag == .windows) {
return error.UnsupportedMedium;
}
@@ -154,8 +203,8 @@ pub const LoadingImage = struct {
.png => stat_size,
// For these formats we have a size we must have.
- .gray, .gray_alpha, .rgb, .rgba => |f| size: {
- const bpp = f.bpp();
+ .gray, .gray_alpha, .rgb, .rgba => size: {
+ const bpp = command.Transmission.formatBpp(self.image.format);
break :size self.image.width * self.image.height * bpp;
},
};
@@ -281,17 +330,16 @@ pub const LoadingImage = struct {
fn isPathInTempDir(path: []const u8) bool {
if (std.mem.startsWith(u8, path, "/tmp")) return true;
if (std.mem.startsWith(u8, path, "/dev/shm")) return true;
- if (temp_dir.allocTmpDir(std.heap.page_allocator)) |dir| {
- defer temp_dir.freeTmpDir(std.heap.page_allocator, dir);
- if (std.mem.startsWith(u8, path, dir)) return true;
-
- // The temporary dir is sometimes a symlink. On macOS for
- // example /tmp is /private/var/...
- var buf: [std.fs.max_path_bytes]u8 = undefined;
- if (posix.realpath(dir, &buf)) |real_dir| {
- if (std.mem.startsWith(u8, path, real_dir)) return true;
- } else |_| {}
- }
+ const dir = temp_dir.allocTmpDir(std.heap.page_allocator) catch return false;
+ defer temp_dir.freeTmpDir(std.heap.page_allocator, dir);
+ if (std.mem.startsWith(u8, path, dir)) return true;
+
+ // The temporary dir is sometimes a symlink. On macOS for
+ // example /tmp is /private/var/...
+ var buf: [std.fs.max_path_bytes]u8 = undefined;
+ if (posix.realpath(dir, &buf)) |real_dir| {
+ if (std.mem.startsWith(u8, path, real_dir)) return true;
+ } else |_| {}
return false;
}
@@ -342,7 +390,7 @@ pub const LoadingImage = struct {
if (img.width > max_dimension or img.height > max_dimension) return error.DimensionsTooLarge;
// Data length must be what we expect
- const bpp = img.format.bpp();
+ const bpp = command.Transmission.formatBpp(img.format);
const expected_len = img.width * img.height * bpp;
const actual_len = self.data.items.len;
if (actual_len != expected_len) {
@@ -426,13 +474,14 @@ pub const LoadingImage = struct {
fn decodePng(self: *LoadingImage, alloc: Allocator) !void {
assert(self.image.format == .png);
- const result = wuffs.png.decode(
+ const decode_png_fn = sys.decode_png orelse
+ return error.UnsupportedFormat;
+ const result = decode_png_fn(
alloc,
self.data.items,
) catch |err| switch (err) {
- error.WuffsError => return error.InvalidData,
+ error.InvalidData => return error.InvalidData,
error.OutOfMemory => return error.OutOfMemory,
- error.Overflow => return error.InvalidData,
};
defer alloc.free(result.data);
@@ -522,7 +571,7 @@ test "image load with invalid RGB data" {
.data = try alloc.dupe(u8, "AAAA"),
};
defer cmd.deinit(alloc);
- var loading = try LoadingImage.init(alloc, &cmd);
+ var loading = try LoadingImage.init(alloc, &cmd, .direct);
defer loading.deinit(alloc);
}
@@ -540,7 +589,7 @@ test "image load with image too wide" {
.data = try alloc.dupe(u8, "AAAA"),
};
defer cmd.deinit(alloc);
- var loading = try LoadingImage.init(alloc, &cmd);
+ var loading = try LoadingImage.init(alloc, &cmd, .direct);
defer loading.deinit(alloc);
try testing.expectError(error.DimensionsTooLarge, loading.complete(alloc));
}
@@ -559,7 +608,7 @@ test "image load with image too tall" {
.data = try alloc.dupe(u8, "AAAA"),
};
defer cmd.deinit(alloc);
- var loading = try LoadingImage.init(alloc, &cmd);
+ var loading = try LoadingImage.init(alloc, &cmd, .direct);
defer loading.deinit(alloc);
try testing.expectError(error.DimensionsTooLarge, loading.complete(alloc));
}
@@ -583,7 +632,7 @@ test "image load: rgb, zlib compressed, direct" {
),
};
defer cmd.deinit(alloc);
- var loading = try LoadingImage.init(alloc, &cmd);
+ var loading = try LoadingImage.init(alloc, &cmd, .direct);
defer loading.deinit(alloc);
var img = try loading.complete(alloc);
defer img.deinit(alloc);
@@ -611,7 +660,7 @@ test "image load: rgb, not compressed, direct" {
),
};
defer cmd.deinit(alloc);
- var loading = try LoadingImage.init(alloc, &cmd);
+ var loading = try LoadingImage.init(alloc, &cmd, .direct);
defer loading.deinit(alloc);
var img = try loading.complete(alloc);
defer img.deinit(alloc);
@@ -640,7 +689,7 @@ test "image load: rgb, zlib compressed, direct, chunked" {
.data = try alloc.dupe(u8, data[0..1024]),
};
defer cmd.deinit(alloc);
- var loading = try LoadingImage.init(alloc, &cmd);
+ var loading = try LoadingImage.init(alloc, &cmd, .direct);
defer loading.deinit(alloc);
// Read our remaining chunks
@@ -676,7 +725,7 @@ test "image load: rgb, zlib compressed, direct, chunked with zero initial chunk"
} },
};
defer cmd.deinit(alloc);
- var loading = try LoadingImage.init(alloc, &cmd);
+ var loading = try LoadingImage.init(alloc, &cmd, .direct);
defer loading.deinit(alloc);
// Read our remaining chunks
@@ -720,7 +769,7 @@ test "image load: temporary file without correct path" {
.data = try alloc.dupe(u8, path),
};
defer cmd.deinit(alloc);
- try testing.expectError(error.TemporaryFileNotNamedCorrectly, LoadingImage.init(alloc, &cmd));
+ try testing.expectError(error.TemporaryFileNotNamedCorrectly, LoadingImage.init(alloc, &cmd, .all));
// Temporary file should still be there
try tmp_dir.dir.access(path, .{});
@@ -753,7 +802,7 @@ test "image load: rgb, not compressed, temporary file" {
.data = try alloc.dupe(u8, path),
};
defer cmd.deinit(alloc);
- var loading = try LoadingImage.init(alloc, &cmd);
+ var loading = try LoadingImage.init(alloc, &cmd, .all);
defer loading.deinit(alloc);
var img = try loading.complete(alloc);
defer img.deinit(alloc);
@@ -790,7 +839,7 @@ test "image load: rgb, not compressed, regular file" {
.data = try alloc.dupe(u8, path),
};
defer cmd.deinit(alloc);
- var loading = try LoadingImage.init(alloc, &cmd);
+ var loading = try LoadingImage.init(alloc, &cmd, .all);
defer loading.deinit(alloc);
var img = try loading.complete(alloc);
defer img.deinit(alloc);
@@ -799,6 +848,8 @@ test "image load: rgb, not compressed, regular file" {
}
test "image load: png, not compressed, regular file" {
+ if (sys.decode_png == null) return error.SkipZigTest;
+
const testing = std.testing;
const alloc = testing.allocator;
@@ -825,7 +876,7 @@ test "image load: png, not compressed, regular file" {
.data = try alloc.dupe(u8, path),
};
defer cmd.deinit(alloc);
- var loading = try LoadingImage.init(alloc, &cmd);
+ var loading = try LoadingImage.init(alloc, &cmd, .all);
defer loading.deinit(alloc);
var img = try loading.complete(alloc);
defer img.deinit(alloc);
@@ -833,3 +884,161 @@ test "image load: png, not compressed, regular file" {
try testing.expect(img.format == .rgba);
try tmp_dir.dir.access(path, .{});
}
+
+test "limits: direct medium always allowed" {
+ const testing = std.testing;
+ const alloc = testing.allocator;
+
+ var cmd: command.Command = .{
+ .control = .{ .transmit = .{
+ .format = .rgb,
+ .medium = .direct,
+ .width = 1,
+ .height = 1,
+ .image_id = 31,
+ } },
+ .data = try alloc.dupe(u8, "AAAA"),
+ };
+ defer cmd.deinit(alloc);
+
+ // Direct medium should work even with the most restrictive limits
+ var loading = try LoadingImage.init(alloc, &cmd, .direct);
+ defer loading.deinit(alloc);
+}
+
+test "limits: file medium blocked by limits" {
+ const testing = std.testing;
+ const alloc = testing.allocator;
+
+ var tmp_dir = try temp_dir.TempDir.init();
+ defer tmp_dir.deinit();
+ const data = @embedFile("testdata/image-rgb-none-20x15-2147483647-raw.data");
+ try tmp_dir.dir.writeFile(.{
+ .sub_path = "image.data",
+ .data = data,
+ });
+
+ var buf: [std.fs.max_path_bytes]u8 = undefined;
+ const path = try tmp_dir.dir.realpath("image.data", &buf);
+
+ var cmd: command.Command = .{
+ .control = .{ .transmit = .{
+ .format = .rgb,
+ .medium = .file,
+ .compression = .none,
+ .width = 20,
+ .height = 15,
+ .image_id = 31,
+ } },
+ .data = try alloc.dupe(u8, path),
+ };
+ defer cmd.deinit(alloc);
+ try testing.expectError(error.UnsupportedMedium, LoadingImage.init(alloc, &cmd, .direct));
+}
+
+test "limits: file medium allowed by limits" {
+ const testing = std.testing;
+ const alloc = testing.allocator;
+
+ var tmp_dir = try temp_dir.TempDir.init();
+ defer tmp_dir.deinit();
+ const data = @embedFile("testdata/image-rgb-none-20x15-2147483647-raw.data");
+ try tmp_dir.dir.writeFile(.{
+ .sub_path = "image.data",
+ .data = data,
+ });
+
+ var buf: [std.fs.max_path_bytes]u8 = undefined;
+ const path = try tmp_dir.dir.realpath("image.data", &buf);
+
+ var cmd: command.Command = .{
+ .control = .{ .transmit = .{
+ .format = .rgb,
+ .medium = .file,
+ .compression = .none,
+ .width = 20,
+ .height = 15,
+ .image_id = 31,
+ } },
+ .data = try alloc.dupe(u8, path),
+ };
+ defer cmd.deinit(alloc);
+ var loading = try LoadingImage.init(alloc, &cmd, .{
+ .file = true,
+ .temporary_file = false,
+ .shared_memory = false,
+ });
+ defer loading.deinit(alloc);
+}
+
+test "limits: temporary file medium blocked by limits" {
+ const testing = std.testing;
+ const alloc = testing.allocator;
+
+ var tmp_dir = try temp_dir.TempDir.init();
+ defer tmp_dir.deinit();
+ const data = @embedFile("testdata/image-rgb-none-20x15-2147483647-raw.data");
+ try tmp_dir.dir.writeFile(.{
+ .sub_path = "tty-graphics-protocol-image.data",
+ .data = data,
+ });
+
+ var buf: [std.fs.max_path_bytes]u8 = undefined;
+ const path = try tmp_dir.dir.realpath("tty-graphics-protocol-image.data", &buf);
+
+ var cmd: command.Command = .{
+ .control = .{ .transmit = .{
+ .format = .rgb,
+ .medium = .temporary_file,
+ .compression = .none,
+ .width = 20,
+ .height = 15,
+ .image_id = 31,
+ } },
+ .data = try alloc.dupe(u8, path),
+ };
+ defer cmd.deinit(alloc);
+ try testing.expectError(error.UnsupportedMedium, LoadingImage.init(alloc, &cmd, .{
+ .file = true,
+ .temporary_file = false,
+ .shared_memory = true,
+ }));
+
+ // File should still exist since we blocked before reading
+ try tmp_dir.dir.access("tty-graphics-protocol-image.data", .{});
+}
+
+test "limits: temporary file medium allowed by limits" {
+ const testing = std.testing;
+ const alloc = testing.allocator;
+
+ var tmp_dir = try temp_dir.TempDir.init();
+ defer tmp_dir.deinit();
+ const data = @embedFile("testdata/image-rgb-none-20x15-2147483647-raw.data");
+ try tmp_dir.dir.writeFile(.{
+ .sub_path = "tty-graphics-protocol-image.data",
+ .data = data,
+ });
+
+ var buf: [std.fs.max_path_bytes]u8 = undefined;
+ const path = try tmp_dir.dir.realpath("tty-graphics-protocol-image.data", &buf);
+
+ var cmd: command.Command = .{
+ .control = .{ .transmit = .{
+ .format = .rgb,
+ .medium = .temporary_file,
+ .compression = .none,
+ .width = 20,
+ .height = 15,
+ .image_id = 31,
+ } },
+ .data = try alloc.dupe(u8, path),
+ };
+ defer cmd.deinit(alloc);
+ var loading = try LoadingImage.init(alloc, &cmd, .{
+ .file = false,
+ .temporary_file = true,
+ .shared_memory = false,
+ });
+ defer loading.deinit(alloc);
+}
diff --git a/vendor/libghostty-vt/src/terminal/kitty/graphics_storage.zig b/vendor/libghostty-vt/src/terminal/kitty/graphics_storage.zig
index 8ff68e3f..e017d5f7 100644
--- a/vendor/libghostty-vt/src/terminal/kitty/graphics_storage.zig
+++ b/vendor/libghostty-vt/src/terminal/kitty/graphics_storage.zig
@@ -51,6 +51,9 @@ pub const ImageStorage = struct {
/// Non-null if there is an in-progress loading image.
loading: ?*LoadingImage = null,
+ /// The limits of what medium types are allowed for image loading.
+ image_limits: LoadingImage.Limits = .direct,
+
/// The total bytes of image data that have been loaded and the limit.
/// If the limit is reached, the oldest images will be evicted to make
/// space. Unused images take priority.
@@ -89,8 +92,9 @@ pub const ImageStorage = struct {
) !void {
// Special case disabling by quickly deleting all
if (limit == 0) {
+ const image_limits = self.image_limits;
self.deinit(alloc, s);
- self.* = .{};
+ self.* = .{ .image_limits = image_limits };
}
// If we re lowering our limit, check if we need to evict.
@@ -658,9 +662,10 @@ pub const ImageStorage = struct {
}
}
- /// Calculates the size of this placement's image in pixels,
- /// taking in to account the specified rows and columns.
- pub fn calculatedSize(
+ /// Returns the size of this placement's image in pixels,
+ /// taking into account the source rectangle, specified
+ /// rows/columns, and aspect ratio.
+ pub fn pixelSize(
self: Placement,
image: Image,
t: *const terminal.Terminal,
@@ -755,7 +760,7 @@ pub const ImageStorage = struct {
// Otherwise we calculate the pixel size, divide by
// cell size, and round up to the nearest integer.
- const calc_size = self.calculatedSize(image, t);
+ const calc_size = self.pixelSize(image, t);
return .{
.cols = std.math.divCeil(
u32,
@@ -1334,7 +1339,7 @@ test "storage: aspect ratio calculation when only columns or rows specified" {
// that's 100px width. 100px * (9 / 16) = 56.25, which should round
// to a height of 56px.
- const calc_size = placement.calculatedSize(image, &t);
+ const calc_size = placement.pixelSize(image, &t);
try testing.expectEqual(@as(u32, 100), calc_size.width);
try testing.expectEqual(@as(u32, 56), calc_size.height);
}
@@ -1352,7 +1357,7 @@ test "storage: aspect ratio calculation when only columns or rows specified" {
// 100px height. 100px * (16 / 9) = 177.77..., which should round to
// a width of 178px.
- const calc_size = placement.calculatedSize(image, &t);
+ const calc_size = placement.pixelSize(image, &t);
try testing.expectEqual(@as(u32, 178), calc_size.width);
try testing.expectEqual(@as(u32, 100), calc_size.height);
}