@zigc/lib 0.15.0-dev.0 → 0.15.1

package/std/Io/Writer.zig

@@ -917,12 +917,10 @@ pub fn sendFileHeader(
     return n;
 }
 
-/// Asserts nonzero buffer capacity and nonzero `limit`.
+/// Asserts nonzero buffer capacity.
 pub fn sendFileReading(w: *Writer, file_reader: *File.Reader, limit: Limit) FileReadingError!usize {
-    assert(limit != .nothing);
     const dest = limit.slice(try w.writableSliceGreedy(1));
-    const n = try file_reader.interface.readSliceShort(dest);
-    if (n == 0) return error.EndOfStream;
+    const n = try file_reader.read(dest);
     w.advance(n);
     return n;
 }
@@ -2657,8 +2655,7 @@ pub const Allocating = struct {
         if (additional == 0) return error.EndOfStream;
         list.ensureUnusedCapacity(gpa, limit.minInt64(additional)) catch return error.WriteFailed;
         const dest = limit.slice(list.unusedCapacitySlice());
-        const n = try file_reader.interface.readSliceShort(dest);
-        if (n == 0) return error.EndOfStream;
+        const n = try file_reader.read(dest);
         list.items.len += n;
         return n;
     }
@@ -2717,40 +2714,18 @@ test "allocating sendFile" {
 
     const file = try tmp_dir.dir.createFile("input.txt", .{ .read = true });
     defer file.close();
-    var r_buffer: [2]u8 = undefined;
+    var r_buffer: [256]u8 = undefined;
     var file_writer: std.fs.File.Writer = .init(file, &r_buffer);
-    try file_writer.interface.writeAll("abcd");
+    try file_writer.interface.writeByte('h');
     try file_writer.interface.flush();
 
     var file_reader = file_writer.moveToReader();
     try file_reader.seekTo(0);
-    try file_reader.interface.fill(2);
 
     var allocating: Writer.Allocating = .init(testing.allocator);
     defer allocating.deinit();
-    try allocating.ensureUnusedCapacity(1);
-    try testing.expectEqual(4, allocating.writer.sendFileAll(&file_reader, .unlimited));
-    try testing.expectEqualStrings("abcd", allocating.writer.buffered());
-}
-
-test sendFileReading {
-    var tmp_dir = testing.tmpDir(.{});
-    defer tmp_dir.cleanup();
-
-    const file = try tmp_dir.dir.createFile("input.txt", .{ .read = true });
-    defer file.close();
-    var r_buffer: [2]u8 = undefined;
-    var file_writer: std.fs.File.Writer = .init(file, &r_buffer);
-    try file_writer.interface.writeAll("abcd");
-    try file_writer.interface.flush();
 
-    var file_reader = file_writer.moveToReader();
-    try file_reader.seekTo(0);
-    try file_reader.interface.fill(2);
-
-    var w_buffer: [1]u8 = undefined;
-    var discarding: Writer.Discarding = .init(&w_buffer);
-    try testing.expectEqual(4, discarding.writer.sendFileReadingAll(&file_reader, .unlimited));
+    _ = try file_reader.interface.streamRemaining(&allocating.writer);
 }
 
 test writeStruct {

package/std/Target.zig

@@ -3075,10 +3075,6 @@ pub fn cTypeAlignment(target: *const Target, c_type: CType) u16 {
             },
             else => {},
         },
-        .m68k => switch (c_type) {
-            .int, .uint, .long, .ulong => return 2,
-            else => {},
-        },
         .powerpc, .powerpcle, .powerpc64, .powerpc64le => switch (target.os.tag) {
             .aix => switch (c_type) {
                 .double, .longdouble => return 4,
@@ -3179,10 +3175,6 @@ pub fn cTypePreferredAlignment(target: *const Target, c_type: CType) u16 {
                 else => {},
             },
         },
-        .m68k => switch (c_type) {
-            .int, .uint, .long, .ulong => return 2,
-            else => {},
-        },
         .wasm32, .wasm64 => switch (target.os.tag) {
             .emscripten => switch (c_type) {
                 .longdouble => return 8,

package/std/Thread.zig

@@ -83,9 +83,10 @@ pub fn sleep(nanoseconds: u64) void {
                     req = rem;
                     continue;
                 },
-                .FAULT => unreachable,
-                .INVAL => unreachable,
-                .OPNOTSUPP => unreachable,
+                .FAULT,
+                .INVAL,
+                .OPNOTSUPP,
+                => unreachable,
                 else => return,
             }
         }

package/std/c.zig

@@ -2235,70 +2235,40 @@ pub const S = switch (native_os) {
         }
     },
     .dragonfly => struct {
-        pub const IFMT = 0o170000;
-
-        pub const IFIFO = 0o010000;
-        pub const IFCHR = 0o020000;
-        pub const IFDIR = 0o040000;
-        pub const IFBLK = 0o060000;
-        pub const IFREG = 0o100000;
-        pub const IFLNK = 0o120000;
-        pub const IFSOCK = 0o140000;
-        pub const IFWHT = 0o160000;
-
-        pub const ISUID = 0o4000;
-        pub const ISGID = 0o2000;
-        pub const ISVTX = 0o1000;
-        pub const IRWXU = 0o700;
-        pub const IRUSR = 0o400;
-        pub const IWUSR = 0o200;
-        pub const IXUSR = 0o100;
-        pub const IRWXG = 0o070;
-        pub const IRGRP = 0o040;
-        pub const IWGRP = 0o020;
-        pub const IXGRP = 0o010;
-        pub const IRWXO = 0o007;
-        pub const IROTH = 0o004;
-        pub const IWOTH = 0o002;
-        pub const IXOTH = 0o001;
-
         pub const IREAD = IRUSR;
         pub const IEXEC = IXUSR;
         pub const IWRITE = IWUSR;
+        pub const IXOTH = 1;
+        pub const IWOTH = 2;
+        pub const IROTH = 4;
+        pub const IRWXO = 7;
+        pub const IXGRP = 8;
+        pub const IWGRP = 16;
+        pub const IRGRP = 32;
+        pub const IRWXG = 56;
+        pub const IXUSR = 64;
+        pub const IWUSR = 128;
+        pub const IRUSR = 256;
+        pub const IRWXU = 448;
         pub const ISTXT = 512;
         pub const BLKSIZE = 512;
-
-        pub fn ISFIFO(m: u32) bool {
-            return m & IFMT == IFIFO;
-        }
+        pub const ISVTX = 512;
+        pub const ISGID = 1024;
+        pub const ISUID = 2048;
+        pub const IFIFO = 4096;
+        pub const IFCHR = 8192;
+        pub const IFDIR = 16384;
+        pub const IFBLK = 24576;
+        pub const IFREG = 32768;
+        pub const IFDB = 36864;
+        pub const IFLNK = 40960;
+        pub const IFSOCK = 49152;
+        pub const IFWHT = 57344;
+        pub const IFMT = 61440;
 
         pub fn ISCHR(m: u32) bool {
             return m & IFMT == IFCHR;
         }
-
-        pub fn ISDIR(m: u32) bool {
-            return m & IFMT == IFDIR;
-        }
-
-        pub fn ISBLK(m: u32) bool {
-            return m & IFMT == IFBLK;
-        }
-
-        pub fn ISREG(m: u32) bool {
-            return m & IFMT == IFREG;
-        }
-
-        pub fn ISLNK(m: u32) bool {
-            return m & IFMT == IFLNK;
-        }
-
-        pub fn ISSOCK(m: u32) bool {
-            return m & IFMT == IFSOCK;
-        }
-
-        pub fn IWHT(m: u32) bool {
-            return m & IFMT == IFWHT;
-        }
     },
     .haiku => struct {
         pub const IFMT = 0o170000;
@@ -3121,17 +3091,8 @@ pub const SIG = switch (native_os) {
         pub const UNBLOCK = 2;
         pub const SETMASK = 3;
     },
-    // https://github.com/SerenityOS/serenity/blob/046c23f567a17758d762a33bdf04bacbfd088f9f/Kernel/API/POSIX/signal.h
     // https://github.com/SerenityOS/serenity/blob/046c23f567a17758d762a33bdf04bacbfd088f9f/Kernel/API/POSIX/signal_numbers.h
     .serenity => struct {
-        pub const DFL: ?Sigaction.handler_fn = @ptrFromInt(0);
-        pub const ERR: ?Sigaction.handler_fn = @ptrFromInt(maxInt(usize));
-        pub const IGN: ?Sigaction.handler_fn = @ptrFromInt(1);
-
-        pub const BLOCK = 1;
-        pub const UNBLOCK = 2;
-        pub const SETMASK = 3;
-
         pub const INVAL = 0;
         pub const HUP = 1;
         pub const INT = 2;
@@ -5724,23 +5685,6 @@ pub const MSG = switch (native_os) {
         pub const WAITFORONE = 0x2000;
         pub const NOTIFICATION = 0x4000;
     },
-    // https://github.com/openbsd/src/blob/42a7be81bef70c04732f45ec573622effe56b563/sys/sys/socket.h#L506
-    .openbsd => struct {
-        pub const OOB = 0x1;
-        pub const PEEK = 0x2;
-        pub const DONTROUTE = 0x4;
-        pub const EOR = 0x8;
-        pub const TRUNC = 0x10;
-        pub const CTRUNC = 0x20;
-        pub const WAITALL = 0x40;
-        pub const DONTWAIT = 0x80;
-        pub const BCAST = 0x100;
-        pub const MCAST = 0x200;
-        pub const NOSIGNAL = 0x400;
-        pub const CMSG_CLOEXEC = 0x800;
-        pub const WAITFORONE = 0x1000;
-        pub const CMSG_CLOFORK = 0x2000;
-    },
     else => void,
 };
 pub const SOCK = switch (native_os) {
@@ -6720,12 +6664,7 @@ pub const SOMAXCONN = switch (native_os) {
     .windows => ws2_32.SOMAXCONN,
     // https://github.com/SerenityOS/serenity/blob/ac44ec5ebc707f9dd0c3d4759a1e17e91db5d74f/Kernel/API/POSIX/sys/socket.h#L128
     .solaris, .illumos, .serenity => 128,
-    // https://github.com/freebsd/freebsd-src/blob/9ab31f821ad1c6bad474510447387c50bef2c24c/sys/sys/socket.h#L434
-    // https://github.com/DragonFlyBSD/DragonFlyBSD/blob/fd3d1949d526ffa646e57037770acd6f2f3bb617/sys/sys/socket.h#L393
-    // https://github.com/NetBSD/src/blob/a673fb3f8487e974c669216064f7588207229fea/sys/sys/socket.h#L472
-    // https://github.com/openbsd/src/blob/8ba9cd88f10123fef7af805b8e5ccc2463ad8fa4/sys/sys/socket.h#L483
-    // https://github.com/apple/darwin-xnu/blob/2ff845c2e033bd0ff64b5b6aa6063a1f8f65aa32/bsd/sys/socket.h#L815
-    .freebsd, .dragonfly, .netbsd, .openbsd, .driverkit, .macos, .ios, .tvos, .watchos, .visionos => 128,
+    .openbsd => 28,
     else => void,
 };
 pub const IFNAMESIZE = switch (native_os) {

package/std/crypto/aes_ocb.zig

@@ -155,12 +155,12 @@ fn AesOcb(comptime Aes: anytype) type {
                 xorWith(&offset, lx.star);
                 var pad = offset;
                 aes_enc_ctx.encrypt(&pad, &pad);
-                var e = [_]u8{0} ** 16;
-                @memcpy(e[0..leftover], m[i * 16 ..][0..leftover]);
-                e[leftover] = 0x80;
                 for (m[i * 16 ..], 0..) |x, j| {
                     c[i * 16 + j] = pad[j] ^ x;
                 }
+                var e = [_]u8{0} ** 16;
+                @memcpy(e[0..leftover], m[i * 16 ..][0..leftover]);
+                e[leftover] = 0x80;
                 xorWith(&sum, e);
             }
             var e = xorBlocks(xorBlocks(sum, offset), lx.dol);
@@ -354,32 +354,3 @@ test "AesOcb test vector 4" {
     try Aes128Ocb.decrypt(&m2, &c, tag, &ad, nonce, k);
     assert(mem.eql(u8, &m, &m2));
 }
-
-test "AesOcb in-place encryption-decryption" {
-    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
-
-    var k: [Aes128Ocb.key_length]u8 = undefined;
-    var nonce: [Aes128Ocb.nonce_length]u8 = undefined;
-    var tag: [Aes128Ocb.tag_length]u8 = undefined;
-    var m: [40]u8 = undefined;
-    var original_m: [m.len]u8 = undefined;
-    _ = try hexToBytes(&k, "000102030405060708090A0B0C0D0E0F");
-    _ = try hexToBytes(&m, "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F2021222324252627");
-    _ = try hexToBytes(&nonce, "BBAA9988776655443322110D");
-    const ad = m;
-
-    @memcpy(&original_m, &m);
-
-    Aes128Ocb.encrypt(&m, &tag, &m, &ad, nonce, k);
-
-    var expected_c: [m.len]u8 = undefined;
-    var expected_tag: [tag.len]u8 = undefined;
-    _ = try hexToBytes(&expected_tag, "ED07BA06A4A69483A7035490C5769E60");
-    _ = try hexToBytes(&expected_c, "D5CA91748410C1751FF8A2F618255B68A0A12E093FF454606E59F9C1D0DDC54B65E8628E568BAD7A");
-
-    try testing.expectEqualSlices(u8, &expected_tag, &tag);
-    try testing.expectEqualSlices(u8, &expected_c, &m);
-    try Aes128Ocb.decrypt(&m, &m, tag, &ad, nonce, k);
-
-    try testing.expectEqualSlices(u8, &original_m, &m);
-}

package/std/crypto/tls/Client.zig

@@ -320,7 +320,6 @@ pub fn init(input: *Reader, output: *Writer, options: Options) InitError!Client
     var handshake_state: HandshakeState = .hello;
     var handshake_cipher: tls.HandshakeCipher = undefined;
     var main_cert_pub_key: CertificatePublicKey = undefined;
-    var tls12_negotiated_group: ?tls.NamedGroup = null;
     const now_sec = std.time.timestamp();
 
     var cleartext_fragment_start: usize = 0;
@@ -680,7 +679,6 @@ pub fn init(input: *Reader, output: *Writer, options: Options) InitError!Client
                         const curve_type = hsd.decode(u8);
                         if (curve_type != 0x03) return error.TlsIllegalParameter; // named_curve
                         const named_group = hsd.decode(tls.NamedGroup);
-                        tls12_negotiated_group = named_group;
                         const key_size = hsd.decode(u8);
                         try hsd.ensure(key_size);
                         const server_pub_key = hsd.slice(key_size);
@@ -693,19 +691,10 @@ pub fn init(input: *Reader, output: *Writer, options: Options) InitError!Client
                         if (cipher_state != .cleartext) return error.TlsUnexpectedMessage;
                         if (handshake_state != .server_hello_done) return error.TlsUnexpectedMessage;
 
-                        const public_key_bytes: []const u8 = switch (tls12_negotiated_group orelse .secp256r1) {
-                            .secp256r1 => &key_share.secp256r1_kp.public_key.toUncompressedSec1(),
-                            .secp384r1 => &key_share.secp384r1_kp.public_key.toUncompressedSec1(),
-                            .x25519 => &key_share.x25519_kp.public_key,
-                            else => return error.TlsIllegalParameter,
-                        };
-
-                        const client_key_exchange_prefix = .{@intFromEnum(tls.ContentType.handshake)} ++
+                        const client_key_exchange_msg = .{@intFromEnum(tls.ContentType.handshake)} ++
                             int(u16, @intFromEnum(tls.ProtocolVersion.tls_1_2)) ++
-                            int(u16, @intCast(public_key_bytes.len + 5)) ++ // record length
-                            .{@intFromEnum(tls.HandshakeType.client_key_exchange)} ++
-                            int(u24, @intCast(public_key_bytes.len + 1)) ++ // handshake message length
-                            .{@as(u8, @intCast(public_key_bytes.len))}; // public key length
+                            array(u16, u8, .{@intFromEnum(tls.HandshakeType.client_key_exchange)} ++
+                                array(u24, u8, array(u8, u8, key_share.secp256r1_kp.public_key.toUncompressedSec1())));
                         const client_change_cipher_spec_msg = .{@intFromEnum(tls.ContentType.change_cipher_spec)} ++
                             int(u16, @intFromEnum(tls.ProtocolVersion.tls_1_2)) ++
                             array(u16, tls.ChangeCipherSpecType, .{.change_cipher_spec});
@@ -714,8 +703,7 @@ pub fn init(input: *Reader, output: *Writer, options: Options) InitError!Client
                             inline else => |*p| {
                                 const P = @TypeOf(p.*).A;
                                 p.transcript_hash.update(wrapped_handshake);
-                                p.transcript_hash.update(client_key_exchange_prefix[tls.record_header_len..]);
-                                p.transcript_hash.update(public_key_bytes);
+                                p.transcript_hash.update(client_key_exchange_msg[tls.record_header_len..]);
                                 const master_secret = hmacExpandLabel(P.Hmac, pre_master_secret, &.{
                                     "master secret",
                                     &client_hello_rand,
@@ -769,9 +757,8 @@ pub fn init(input: *Reader, output: *Writer, options: Options) InitError!Client
                                     nonce,
                                     pv.app_cipher.client_write_key,
                                 );
-                                var all_msgs_vec: [4][]const u8 = .{
-                                    &client_key_exchange_prefix,
-                                    public_key_bytes,
+                                var all_msgs_vec: [3][]const u8 = .{
+                                    &client_key_exchange_msg,
                                     &client_change_cipher_spec_msg,
                                     &client_verify_msg,
                                 };
@@ -942,6 +929,7 @@ fn drain(w: *Writer, data: []const []const u8, splat: usize) Writer.Error!usize
             if (prepared.cleartext_len < buf.len) break :done;
         }
         for (data[0 .. data.len - 1]) |buf| {
+            if (buf.len < min_buffer_len) break :done;
             const prepared = prepareCiphertextRecord(c, ciphertext_buf[ciphertext_end..], buf, .application_data);
             total_clear += prepared.cleartext_len;
             ciphertext_end += prepared.ciphertext_end;
@@ -949,6 +937,7 @@ fn drain(w: *Writer, data: []const []const u8, splat: usize) Writer.Error!usize
         }
         const buf = data[data.len - 1];
         for (0..splat) |_| {
+            if (buf.len < min_buffer_len) break :done;
             const prepared = prepareCiphertextRecord(c, ciphertext_buf[ciphertext_end..], buf, .application_data);
             total_clear += prepared.cleartext_len;
             ciphertext_end += prepared.ciphertext_end;

package/std/debug.zig

@@ -569,7 +569,7 @@ pub fn assertReadable(slice: []const volatile u8) void {
 /// Invokes detectable illegal behavior when the provided array is not aligned
 /// to the provided amount.
 pub fn assertAligned(ptr: anytype, comptime alignment: std.mem.Alignment) void {
-    const aligned_ptr: *align(alignment.toByteUnits()) const anyopaque = @ptrCast(@alignCast(ptr));
+    const aligned_ptr: *align(alignment.toByteUnits()) anyopaque = @ptrCast(@alignCast(ptr));
     _ = aligned_ptr;
 }
 

package/std/fs/Dir.zig

@@ -2583,9 +2583,8 @@ pub fn updateFile(
         error.ReadFailed => return src_reader.err.?,
         error.WriteFailed => return atomic_file.file_writer.err.?,
     };
-    try atomic_file.flush();
     try atomic_file.file_writer.file.updateTimes(src_stat.atime, src_stat.mtime);
-    try atomic_file.renameIntoPlace();
+    try atomic_file.finish();
     return .stale;
 }