Something went wrong. Try again.
Builds Windows Installer packages from WiX sources on Linux or Windows, in pure Zig; a clean-room reimplementation of msitools' wixl.
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293// SPDX-FileCopyrightText: © 2026 Jeffrey C. Ollie <jeff@ocjtech.us>// SPDX-License-Identifier: MIT
//! The version of a Windows program or library: what the File table's//! Version and Language columns record, from the VS_VERSIONINFO resource//! of a file in the Portable Executable format.//!//! Windows Installer compares a file it is installing with one already on//! disk by these, and a file with a version always wins over one without://! a package that leaves them blank leaves an older program in place.//!//! Written from Microsoft's "PE Format" specification and its documentation//! of VS_VERSIONINFO, VS_FIXEDFILEINFO, VarFileInfo and Var. Anything that//! is not a well-formed version resource in a well-formed PE file is no//! version at all, rather than an error: the file is installed as data.
const std = @import("std");
pub const FileVersion = struct { /// From VS_FIXEDFILEINFO's dwFileVersionMS and dwFileVersionLS. version: [4]u16, /// The languages the resource is translated into, as the File table's /// Language column lists them: decimal language IDs, separated by /// commas. From VarFileInfo's Translation, or, without one, the /// language the resource itself is filed under. language_buffer: [max_language]u8 = undefined, language_len: usize = 0,
/// The File table's Language column is an S20. pub const max_language = 20;
pub fn language(v: *const FileVersion) []const u8 { return v.language_buffer[0..v.language_len]; }
pub fn format(v: FileVersion, w: *std.Io.Writer) std.Io.Writer.Error!void { try w.print("{d}.{d}.{d}.{d}", .{ v.version[0], v.version[1], v.version[2], v.version[3] }); }
/// Adds a language to the list, unless it is there already or would /// not fit. fn addLanguage(v: *FileVersion, id: u16) void { var digits: [5]u8 = undefined; const text = std.fmt.bufPrint(&digits, "{d}", .{id}) catch unreachable; var it = std.mem.splitScalar(u8, v.language(), ','); if (v.language_len != 0) while (it.next()) |have| { if (std.mem.eql(u8, have, text)) return; }; const comma: usize = @intFromBool(v.language_len != 0); if (v.language_len + comma + text.len > max_language) return; if (comma != 0) v.language_buffer[v.language_len] = ','; @memcpy(v.language_buffer[v.language_len + comma ..][0..text.len], text); v.language_len += comma + text.len; }};
/// The file's version, or null if it has none: if it is not a PE file, has/// no version resource, or the resource has no VS_FIXEDFILEINFO.pub fn fileVersion(bytes: []const u8) ?FileVersion { const image = Image.parse(bytes) orelse return null; const resource = image.versionResource() orelse return null; return parseVersionInfo(resource.data, resource.language);}
fn read(comptime T: type, bytes: []const u8, offset: usize) ?T { const end = std.math.add(usize, offset, @sizeOf(T)) catch return null; if (end > bytes.len) return null; return std.mem.readInt(T, bytes[offset..][0..@sizeOf(T)], .little);}
fn align4(n: usize) usize { return std.mem.alignForward(usize, n, 4);}
/// The parts of a PE file that lead to its resources.const Image = struct { bytes: []const u8, /// Where the section table begins, and how many sections it holds. sections: usize, section_count: u16, /// The resource table's address, as an RVA. resource_rva: u32, resource_size: u32,
/// The resource table's index among the optional header's data /// directories. const resource_directory = 2; const section_header_size = 40;
fn parse(bytes: []const u8) ?Image { if (bytes.len < 0x40 or !std.mem.eql(u8, bytes[0..2], "MZ")) return null; const pe = read(u32, bytes, 0x3C) orelse return null; if ((read(u32, bytes, pe) orelse return null) != 0x00004550) return null; // "PE\0\0" const coff = @as(usize, pe) + 4; const section_count = read(u16, bytes, coff + 2) orelse return null; const optional_size = read(u16, bytes, coff + 16) orelse return null; const optional = coff + 20; // PE32 and PE32+ differ in where the data directories begin. const directories: usize = switch (read(u16, bytes, optional) orelse return null) { 0x10B => 96, 0x20B => 112, else => return null, }; const count = read(u32, bytes, optional + directories - 4) orelse return null; if (count <= resource_directory) return null; const entry = directories + resource_directory * 8; if (entry + 8 > optional_size) return null; return .{ .bytes = bytes, .sections = optional + optional_size, .section_count = section_count, .resource_rva = read(u32, bytes, optional + entry) orelse return null, .resource_size = read(u32, bytes, optional + entry + 4) orelse return null, }; }
/// The bytes at an RVA, as far as the section holding it has them in /// the file. fn at(image: Image, rva: u32, size: u32) ?[]const u8 { for (0..image.section_count) |i| { const header = image.sections + i * section_header_size; const address = read(u32, image.bytes, header + 12) orelse return null; const raw_size = read(u32, image.bytes, header + 16) orelse return null; const raw = read(u32, image.bytes, header + 20) orelse return null; if (rva < address or rva - address >= raw_size) continue; const offset = rva - address; if (@as(u64, offset) + size > raw_size) return null; const start = @as(u64, raw) + offset; if (start + size > image.bytes.len) return null; return image.bytes[@intCast(start)..][0..size]; } return null; }
const Resource = struct { data: []const u8, language: u16 };
/// The first version resource: the resource directory's first entry of /// type RT_VERSION, the first name under it, and the first language /// under that. fn versionResource(image: Image) ?Resource { if (image.resource_size == 0) return null; const table = image.at(image.resource_rva, image.resource_size) orelse return null; const rt_version = 16; const names = subdirectory(table, 0, rt_version) orelse return null; const languages = subdirectory(table, names, null) orelse return null; const leaf = entryOf(table, languages, null) orelse return null; // A leaf, not another directory. if (leaf.offset & 0x8000_0000 != 0) return null; const data_rva = read(u32, table, leaf.offset) orelse return null; const data_size = read(u32, table, leaf.offset + 4) orelse return null; return .{ .data = image.at(data_rva, data_size) orelse return null, // A language filed under a name rather than an ID is none. .language = if (leaf.id & 0x8000_0000 != 0) 0 else @truncate(leaf.id), }; }
const Entry = struct { id: u32, offset: u32 };
/// The entry of the directory at `offset` with the integer ID `id`, or /// its first entry of any kind when `id` is null. fn entryOf(table: []const u8, offset: u32, id: ?u32) ?Entry { const named = read(u16, table, offset + 12) orelse return null; const numbered = read(u16, table, offset + 14) orelse return null; for (0..@as(usize, named) + numbered) |i| { const e = @as(usize, offset) + 16 + i * 8; const entry: Entry = .{ .id = read(u32, table, e) orelse return null, .offset = read(u32, table, e + 4) orelse return null, }; if (id) |want| { if (entry.id & 0x8000_0000 != 0 or entry.id != want) continue; } return entry; } return null; }
/// The offset of the subdirectory an entry leads to. fn subdirectory(table: []const u8, offset: u32, id: ?u32) ?u32 { const entry = entryOf(table, offset, id) orelse return null; if (entry.offset & 0x8000_0000 == 0) return null; const sub = entry.offset & 0x7FFF_FFFF; // Each level is deeper in the table than the one before, so a // malformed table cannot send this round in a circle. if (sub <= offset) return null; return sub; }};
/// A block of a version resource: VS_VERSIONINFO, or one of the/// StringFileInfo, VarFileInfo and Var structures under it, each a length,/// a value's length, a type, a key, then the value and the blocks it holds.const Block = struct { bytes: []const u8, value_length: u16, /// Where the key ends, and the value begins. value: usize,
fn parse(bytes: []const u8) ?Block { const length = read(u16, bytes, 0) orelse return null; if (length < 6 or length > bytes.len) return null; const block = bytes[0..length]; var end: usize = 6; while (true) : (end += 2) { if ((read(u16, block, end) orelse return null) == 0) break; } return .{ .bytes = block, .value_length = read(u16, block, 2).?, .value = align4(end + 2), }; }
/// Whether the key, which is UTF-16, is this ASCII text. fn keyIs(b: Block, key: []const u8) bool { if (b.value - 6 < key.len * 2 + 2) return false; for (key, 0..) |c, i| { if (read(u16, b.bytes, 6 + i * 2) != c) return false; } return read(u16, b.bytes, 6 + key.len * 2) == 0; }
/// The blocks this one holds, beginning after a value of `value_size` /// bytes. fn children(b: Block, value_size: usize) Children { return .{ .bytes = b.bytes, .at = align4(b.value + value_size) }; }
const Children = struct { bytes: []const u8, at: usize,
fn next(c: *Children) ?Block { if (c.at >= c.bytes.len) return null; const child = Block.parse(c.bytes[c.at..]) orelse return null; c.at = align4(c.at + child.bytes.len); return child; } };};
fn parseVersionInfo(data: []const u8, resource_language: u16) ?FileVersion { const root = Block.parse(data) orelse return null; if (!root.keyIs("VS_VERSION_INFO")) return null; // VS_FIXEDFILEINFO: a signature, the structure's version, then the // file's version, most significant half first. const fixed_size = 52; if (root.value_length < fixed_size) return null; if (read(u32, root.bytes, root.value) != 0xFEEF04BD) return null; const ms = read(u32, root.bytes, root.value + 8) orelse return null; const ls = read(u32, root.bytes, root.value + 12) orelse return null; var result: FileVersion = .{ .version = .{ @truncate(ms >> 16), @truncate(ms), @truncate(ls >> 16), @truncate(ls), } };
var blocks = root.children(root.value_length); while (blocks.next()) |block| { if (!block.keyIs("VarFileInfo")) continue; var vars = block.children(0); while (vars.next()) |v| { if (!v.keyIs("Translation")) continue; // Pairs of a language ID and a code page, a word each. var i: usize = 0; while (i + 4 <= v.value_length) : (i += 4) { const language = read(u16, v.bytes, v.value + i) orelse break; result.addLanguage(language); } } } if (result.language_len == 0) result.addLanguage(resource_language); return result;}
test "not a PE file has no version" { try std.testing.expect(fileVersion("not really a program\n") == null); try std.testing.expect(fileVersion("") == null); try std.testing.expect(fileVersion("MZ" ++ @as([0x3E]u8, @splat(0))) == null);}
test "languages are listed once each, as long as they fit" { var v: FileVersion = .{ .version = @splat(0) }; v.addLanguage(1033); v.addLanguage(1031); v.addLanguage(1033); try std.testing.expectEqualStrings("1033,1031", v.language()); v.addLanguage(1036); v.addLanguage(3082); // "1033,1031,1036,3082" is 19; another would make 24. v.addLanguage(2052); try std.testing.expectEqualStrings("1033,1031,1036,3082", v.language());}