Skip to content

Run a virtual iPhone on an Apple Silicon Mac.

Swift
4.7 KB
Raw Blame
import Foundation

/// One launchd service as `services.list` and `services.status` report it.
struct VPhoneServiceRow: Identifiable, Hashable {
    let label: String
    var domains: [String]
    var isRunning: Bool
    /// The running instance's pid; nil when launchd reports none.
    var pid: Int?
    /// launchd's `LastExitStatus`: a wait(2) status, not an exit code.
    var lastExitStatus: Int?
    var program: String?
    /// The system domain's override: true disabled, false explicitly
    /// enabled, nil when launchd has no override for the label.
    var disabled: Bool?

    var id: String {
        label
    }

    // MARK: - Parsing

    /// Reads a `services.list` row or a `services.status` payload. The list
    /// carries `disabled` only for overridden labels; status carries
    /// `enabled` and `override` instead.
    init?(_ object: [String: Any]) {
        guard let label = object.string("label"), !label.isEmpty else { return nil }
        self.label = label
        domains = object["domains"] as? [String] ?? []
        let pid = object.int("pid") ?? 0
        self.pid = pid > 0 ? pid : nil
        isRunning = object.bool("running") ?? (pid > 0)
        lastExitStatus = object.int("last_exit_status")
        program = object.string("program").flatMap { $0.isEmpty ? nil : $0 }
        if let disabled = object.bool("disabled") {
            self.disabled = disabled
        } else if object.bool("override") == true {
            disabled = !(object.bool("enabled") ?? true)
        } else {
            disabled = nil
        }
    }

    init(
        label: String,
        domains: [String] = ["system"],
        isRunning: Bool = false,
        pid: Int? = nil,
        lastExitStatus: Int? = nil,
        program: String? = nil,
        disabled: Bool? = nil,
    ) {
        self.label = label
        self.domains = domains
        self.isRunning = isRunning
        self.pid = pid
        self.lastExitStatus = lastExitStatus
        self.program = program
        self.disabled = disabled
    }

    // MARK: - Sort Keys

    var stateRank: Int {
        isRunning ? 0 : 1
    }

    var pidValue: Int {
        pid ?? 0
    }

    var lastExitValue: Int {
        lastExitStatus ?? 0
    }

    var disabledRank: Int {
        switch disabled {
        case true: 0
        case false: 1
        case nil: 2
        }
    }

    var domainText: String {
        domains.joined(separator: ", ")
    }

    var programText: String {
        program ?? ""
    }

    // MARK: - Display

    var pidText: String {
        pid.map(String.init) ?? "—"
    }

    var disabledText: String {
        switch disabled {
        case true: String(localized: "Yes", bundle: VPhoneLocalization.bundle)
        case false: String(localized: "No", bundle: VPhoneLocalization.bundle)
        case nil: "—"
        }
    }

    var lastExit: VPhoneServiceExit {
        VPhoneServiceExit(status: lastExitStatus)
    }
}

// MARK: - Last Exit

/// Decodes launchd's `LastExitStatus` wait status into an exit code or the
/// signal that ended the process.
struct VPhoneServiceExit {
    let status: Int?

    /// `0`, an exit code such as `1`, or a signal such as `SIGKILL`.
    var text: String {
        guard let status else { return "—" }
        if status == 0 {
            return "0"
        }
        // launchctl prints a signalled exit as a negative number; accept it.
        if status < 0 {
            return Self.signalName(-status)
        }
        let signal = status & 0x7F
        if signal == 0 {
            return String((status >> 8) & 0xFF)
        }
        if signal != 0x7F {
            return status & 0x80 != 0 ? "\(Self.signalName(signal))+core" : Self.signalName(signal)
        }
        return String(status)
    }

    var isAbnormal: Bool {
        (status ?? 0) != 0
    }

    var help: String {
        guard let status else {
            return String(localized: "launchd has not reported an exit.", bundle: VPhoneLocalization.bundle)
        }
        return String(localized: "Wait status \(status)", bundle: VPhoneLocalization.bundle)
    }

    static func signalName(_ number: Int) -> String {
        let names = [
            1: "SIGHUP", 2: "SIGINT", 3: "SIGQUIT", 4: "SIGILL", 5: "SIGTRAP", 6: "SIGABRT",
            7: "SIGEMT", 8: "SIGFPE", 9: "SIGKILL", 10: "SIGBUS", 11: "SIGSEGV", 12: "SIGSYS",
            13: "SIGPIPE", 14: "SIGALRM", 15: "SIGTERM", 16: "SIGURG", 17: "SIGSTOP",
            18: "SIGTSTP", 19: "SIGCONT", 20: "SIGCHLD", 21: "SIGTTIN", 22: "SIGTTOU",
            23: "SIGIO", 24: "SIGXCPU", 25: "SIGXFSZ", 26: "SIGVTALRM", 27: "SIGPROF",
            28: "SIGWINCH", 29: "SIGINFO", 30: "SIGUSR1", 31: "SIGUSR2",
        ]
        return names[number] ?? "SIG\(number)"
    }
}