1const std = @import("std");
  2const builtin = @import("builtin");
  3
  4const native_os = builtin.target.os.tag;
  5
  6pub fn main() !void {
  7    if (native_os == .wasi or native_os == .windows) {
  8        return; // no sigaction
  9    }
 10
 11    try test_sigaction();
 12    try test_sigset_bits();
 13}
 14
 15fn test_sigaction() !void {
 16    if (native_os == .macos and builtin.target.cpu.arch == .x86_64) {
 17        return; // https://github.com/ziglang/zig/issues/15381
 18    }
 19
 20    const test_signo: std.posix.SIG = .URG; // URG only because it is ignored by default in debuggers
 21
 22    const S = struct {
 23        var handler_called_count: u32 = 0;
 24
 25        fn handler(sig: std.posix.SIG, info: *const std.posix.siginfo_t, ctx_ptr: ?*anyopaque) callconv(.c) void {
 26            _ = ctx_ptr;
 27            // Check that we received the correct signal.
 28            const info_sig = switch (native_os) {
 29                .netbsd => info.info.signo,
 30                else => info.signo,
 31            };
 32            if (sig == test_signo and sig == info_sig) {
 33                handler_called_count += 1;
 34            }
 35        }
 36    };
 37
 38    var sa: std.posix.Sigaction = .{
 39        .handler = .{ .sigaction = &S.handler },
 40        .mask = std.posix.sigemptyset(),
 41        .flags = std.posix.SA.SIGINFO | std.posix.SA.RESETHAND,
 42    };
 43
 44    var old_sa: std.posix.Sigaction = undefined;
 45
 46    // Install the new signal handler.
 47    std.posix.sigaction(test_signo, &sa, null);
 48
 49    // Check that we can read it back correctly.
 50    std.posix.sigaction(test_signo, null, &old_sa);
 51    try std.testing.expectEqual(&S.handler, old_sa.handler.sigaction.?);
 52    try std.testing.expect((old_sa.flags & std.posix.SA.SIGINFO) != 0);
 53
 54    // Invoke the handler.
 55    try std.posix.raise(test_signo);
 56    try std.testing.expectEqual(1, S.handler_called_count);
 57
 58    // Check if passing RESETHAND correctly reset the handler to SIG_DFL
 59    std.posix.sigaction(test_signo, null, &old_sa);
 60    try std.testing.expectEqual(std.posix.SIG.DFL, old_sa.handler.handler);
 61
 62    // Reinstall the signal w/o RESETHAND and re-raise
 63    sa.flags = std.posix.SA.SIGINFO;
 64    std.posix.sigaction(test_signo, &sa, null);
 65    try std.posix.raise(test_signo);
 66    try std.testing.expectEqual(2, S.handler_called_count);
 67
 68    // Now set the signal to ignored
 69    sa.handler = .{ .handler = std.posix.SIG.IGN };
 70    sa.flags = 0;
 71    std.posix.sigaction(test_signo, &sa, null);
 72
 73    // Re-raise to ensure handler is actually ignored
 74    try std.posix.raise(test_signo);
 75    try std.testing.expectEqual(2, S.handler_called_count);
 76
 77    // Ensure that ignored state is returned when querying
 78    std.posix.sigaction(test_signo, null, &old_sa);
 79    try std.testing.expectEqual(std.posix.SIG.IGN, old_sa.handler.handler);
 80}
 81
 82fn test_sigset_bits() !void {
 83    const S = struct {
 84        var expected_sig: std.posix.SIG = undefined;
 85        var seen_sig: ?std.posix.SIG = null;
 86
 87        fn handler(sig: std.posix.SIG, info: *const std.posix.siginfo_t, ctx_ptr: ?*anyopaque) callconv(.c) void {
 88            _ = ctx_ptr;
 89
 90            const info_sig = switch (native_os) {
 91                .netbsd => info.info.signo,
 92                else => info.signo,
 93            };
 94            if (seen_sig == null and sig == expected_sig and sig == info_sig) {
 95                seen_sig = sig;
 96            }
 97        }
 98    };
 99
100    // Assume this is a single-threaded process where the current thread has the
101    // 'pid' thread id.  (The sigprocmask calls are thread-private state.)
102    const self_tid = std.posix.system.getpid();
103
104    // To check that sigset_t mapping matches kernel (think u32/u64 mismatches on
105    // big-endian), try sending a blocked signal to make sure the mask matches the
106    // signal.  (Send URG and CHLD because they're ignored by default in the
107    // debugger, vs. USR1 or other named signals)
108    inline for ([_]std.posix.SIG{ .URG, .CHLD }) |test_signo| {
109        S.expected_sig = test_signo;
110        S.seen_sig = null;
111
112        const sa: std.posix.Sigaction = .{
113            .handler = .{ .sigaction = &S.handler },
114            .mask = std.posix.sigemptyset(),
115            .flags = std.posix.SA.SIGINFO | std.posix.SA.RESETHAND,
116        };
117
118        var old_sa: std.posix.Sigaction = undefined;
119
120        // Install the new signal handler.
121        std.posix.sigaction(test_signo, &sa, &old_sa);
122
123        // block the signal and see that its delayed until unblocked
124        var block_one: std.posix.sigset_t = std.posix.sigemptyset();
125        std.posix.sigaddset(&block_one, test_signo);
126        std.posix.sigprocmask(std.posix.SIG.BLOCK, &block_one, null);
127
128        // qemu maps target signals to host signals 1-to-1, so targets
129        // with more signals than the host will fail to send the signal.
130        const rc = std.posix.system.kill(self_tid, test_signo);
131        switch (std.posix.errno(rc)) {
132            .SUCCESS => {
133                // See that the signal is blocked, then unblocked
134                try std.testing.expectEqual(null, S.seen_sig);
135                std.posix.sigprocmask(std.posix.SIG.UNBLOCK, &block_one, null);
136                try std.testing.expectEqual(test_signo, S.seen_sig);
137            },
138            .INVAL => {
139                // Signal won't get delviered.  Just clean up.
140                std.posix.sigprocmask(std.posix.SIG.UNBLOCK, &block_one, null);
141                try std.testing.expectEqual(null, S.seen_sig);
142            },
143            else => |errno| return std.posix.unexpectedErrno(errno),
144        }
145
146        // Restore original handler
147        std.posix.sigaction(test_signo, &old_sa, null);
148    }
149}