mutating func readChannelRequestMessage()

in Sources/NIOSSH/SSHMessages.swift [985:1083]
91 lines of code
11 McCabe index (conditional complexity)

    mutating func readChannelRequestMessage() throws -> SSHMessage.ChannelRequestMessage? {
        try self.rewindOnNilOrError { `self` in
            guard
                let recipientChannel: UInt32 = self.readInteger(),
                let typeRawValue = self.readSSHStringAsString()
            else {
                return nil
            }

            guard let wantReply = self.readSSHBoolean() else {
                return nil
            }

            let type: SSHMessage.ChannelRequestMessage.RequestType
            switch typeRawValue {
            case "exec":
                guard let command = self.readSSHStringAsString() else {
                    return nil
                }
                type = .exec(command)
            case "exit-status":
                guard let status: UInt32 = self.readInteger() else {
                    return nil
                }
                type = .exitStatus(status)
            case "env":
                guard
                    let name = self.readSSHStringAsString(),
                    let value = self.readSSHStringAsString()
                else {
                    return nil
                }

                type = .env(name, value)
            case "exit-signal":
                guard
                    let signalName = self.readSSHStringAsString(),
                    let coreDumped = self.readSSHBoolean(),
                    let errorMessage = self.readSSHStringAsString(),
                    let language = self.readSSHStringAsString()
                else {
                    return nil
                }

                type = .exitSignal(signalName, coreDumped, errorMessage, language)
            case "pty-req":
                guard
                    let termVariable = self.readSSHStringAsString(),
                    let termWidth = self.readInteger(as: UInt32.self),
                    let termHeight = self.readInteger(as: UInt32.self),
                    let pixelWidth = self.readInteger(as: UInt32.self),
                    let pixelHeight = self.readInteger(as: UInt32.self),
                    var encodedTerminalModes = self.readSSHString()
                else {
                    return nil
                }

                type = .ptyReq(.init(termVariable: termVariable,
                                     characterWidth: termWidth,
                                     rowHeight: termHeight,
                                     pixelWidth: pixelWidth,
                                     pixelHeight: pixelHeight,
                                     terminalModes: try encodedTerminalModes.readSSHTerminalModes()))
            case "shell":
                type = .shell
            case "subsystem":
                guard let name = self.readSSHStringAsString() else {
                    return nil
                }
                type = .subsystem(name)
            case "window-change":
                guard
                    let termWidth = self.readInteger(as: UInt32.self),
                    let termHeight = self.readInteger(as: UInt32.self),
                    let pixelWidth = self.readInteger(as: UInt32.self),
                    let pixelHeight = self.readInteger(as: UInt32.self)
                else {
                    return nil
                }

                type = .windowChange(.init(characterWidth: termWidth, rowHeight: termHeight, pixelWidth: pixelWidth, pixelHeight: pixelHeight))
            case "xon-xoff":
                guard let clientCanDo = self.readSSHBoolean() else {
                    return nil
                }
                type = .xonXoff(clientCanDo)

            case "signal":
                guard let signalName = self.readSSHStringAsString() else {
                    return nil
                }
                type = .signal(signalName)
            default:
                type = .unknown
            }

            return SSHMessage.ChannelRequestMessage(recipientChannel: recipientChannel, type: type, wantReply: wantReply)
        }
    }