protected List <TerminalMode> ReadTerminalModes(byte[] encodedModes)
        {
            var termModes = new List <TerminalMode>();
            TerminalModeOpCode opCode;

            // Read modes from encoded byte stream.
            using (var streamReader = new SshStreamReader(new MemoryStream(encodedModes)))
            {
                while (true)
                {
                    opCode = (TerminalModeOpCode)streamReader.ReadByte();

                    if (opCode == TerminalModeOpCode.TtyOpEnd)
                    {
                        break;
                    }
                    if ((byte)opCode >= 1 && (byte)opCode <= 160)
                    {
                        // Add mode to list.
                        termModes.Add(new TerminalMode(opCode, streamReader.ReadUInt32()));
                    }
                    else
                    {
                        // Undefined op code.
                        break;
                    }
                }
            }

            return(termModes);
        }
        internal override bool ProcessMessage(byte[] payload)
        {
            if (_isDisposed)
            {
                throw new ObjectDisposedException(this.GetType().FullName);
            }

            // Check if banner message has not yet been set.
            if (!_bannerMsgSent)
            {
                // Send banner message if one has been specified.
                if (this.BannerMessage != null)
                {
                    SendMsgUserAuthBanner(this.BannerMessage,
                                          this.BannerMessageLanguage);
                }

                _bannerMsgSent = true;
            }

            using (var msgReader = new SshStreamReader(new MemoryStream(payload)))
            {
                // Check message ID.
                SshAuthenticationMessage messageId = (SshAuthenticationMessage)msgReader.ReadByte();

#if DEBUG
                if (System.Enum.IsDefined(typeof(SshAuthenticationMessage), messageId))
                {
                    Debug.WriteLine(string.Format(">>> {0}", System.Enum.GetName(
                                                      typeof(SshAuthenticationMessage), messageId)));
                }
#endif

                switch (messageId)
                {
                // User auth messages
                case SshAuthenticationMessage.Request:
                    ProcessMsgUserAuthRequest(msgReader);
                    break;

                case SshAuthenticationMessage.InfoResponse:
                    ProcessMsgUserInfoResponse(msgReader);
                    break;

                // Unrecognised message
                default:
                    return(false);
                }
            }

            // Message was recognised.
            return(true);
        }
        internal override bool ProcessMessage(byte[] payload)
        {
            if (_isDisposed) throw new ObjectDisposedException(this.GetType().FullName);

            // Check if banner message has not yet been set.
            if (!_bannerMsgSent)
            {
                // Send banner message if one has been specified.
                if (this.BannerMessage != null) SendMsgUserAuthBanner(this.BannerMessage,
                    this.BannerMessageLanguage);

                _bannerMsgSent = true;
            }

            using (var msgReader = new SshStreamReader(new MemoryStream(payload)))
            {
                // Check message ID.
                SshAuthenticationMessage messageId = (SshAuthenticationMessage)msgReader.ReadByte();

            #if DEBUG
                if (System.Enum.IsDefined(typeof(SshAuthenticationMessage), messageId))
                    Debug.WriteLine(string.Format(">>> {0}", System.Enum.GetName(
                        typeof(SshAuthenticationMessage), messageId)));
            #endif

                switch (messageId)
                {
                    // User auth messages
                    case SshAuthenticationMessage.Request:
                        ProcessMsgUserAuthRequest(msgReader);
                        break;
                    case SshAuthenticationMessage.InfoResponse:
                        ProcessMsgUserInfoResponse(msgReader);
                        break;
                    // Unrecognised message
                    default:
                        return false;
                }
            }

            // Message was recognised.
            return true;
        }
        internal override bool ProcessMessage(byte[] payload)
        {
            if (_isDisposed)
            {
                throw new ObjectDisposedException(this.GetType().FullName);
            }

            // Create memory stream from payload data.
            using (var msgStream = new MemoryStream(payload))
                using (var msgReader = new SshStreamReader(msgStream))
                {
                    // Check message ID.
                    SshConnectionMessage messageId = (SshConnectionMessage)msgReader.ReadByte();

#if DEBUG
                    if (System.Enum.IsDefined(typeof(SshConnectionMessage), messageId))
                    {
                        Debug.WriteLine(string.Format(">>> {0}", System.Enum.GetName(
                                                          typeof(SshConnectionMessage), messageId)));
                    }
#endif

                    switch (messageId)
                    {
                    // Global request messages
                    case SshConnectionMessage.GlobalRequest:
                        ProcessMsgGlobalRequest(msgReader);
                        break;

                    case SshConnectionMessage.RequestSuccess:
                        ProcessMsgRequestSuccess(msgReader);
                        break;

                    case SshConnectionMessage.RequestFailure:
                        ProcessMsgRequestFailure(msgReader);
                        break;

                    // Channel messages
                    case SshConnectionMessage.ChannelOpen:
                        ProcessMsgChannelOpen(msgReader);
                        break;

                    case SshConnectionMessage.ChannelOpenConfirmation:
                        ProcessMsgChannelOpenConfirmation(msgReader);
                        break;

                    case SshConnectionMessage.ChannelOpenFailure:
                        ProcessMsgChannelOpenFailure(msgReader);
                        break;

                    case SshConnectionMessage.ChannelEof:
                        ProcessMsgChannelEof(msgReader);
                        break;

                    case SshConnectionMessage.ChannelClose:
                        ProcessMsgChannelClose(msgReader);
                        break;

                    case SshConnectionMessage.ChannelRequest:
                        ProcessMsgChannelRequest(msgReader);
                        break;

                    case SshConnectionMessage.ChannelWindowAdjust:
                        ProcessMsgChannelWindowAdjust(msgReader);
                        break;

                    case SshConnectionMessage.ChannelData:
                        ProcessMsgChannelData(msgReader);
                        break;

                    case SshConnectionMessage.ChannelExtendedData:
                        ProcessMsgChannelExtendedData(msgReader);
                        break;

                    // Unrecognised message
                    default:
                        return(false);
                    }
                }

            // Message was recognised.
            return(true);
        }
        internal override bool ProcessMessage(byte[] payload)
        {
            if (_isDisposed) throw new ObjectDisposedException(this.GetType().FullName);

            // Create memory stream from payload data.
            using (var msgStream = new MemoryStream(payload))
            using (var msgReader = new SshStreamReader(msgStream))
            {
                // Check message ID.
                SshConnectionMessage messageId = (SshConnectionMessage)msgReader.ReadByte();

            #if DEBUG
                if (System.Enum.IsDefined(typeof(SshConnectionMessage), messageId))
                    Debug.WriteLine(string.Format(">>> {0}", System.Enum.GetName(
                        typeof(SshConnectionMessage), messageId)));
            #endif

                switch (messageId)
                {
                    // Global request messages
                    case SshConnectionMessage.GlobalRequest:
                        ProcessMsgGlobalRequest(msgReader);
                        break;
                    case SshConnectionMessage.RequestSuccess:
                        ProcessMsgRequestSuccess(msgReader);
                        break;
                    case SshConnectionMessage.RequestFailure:
                        ProcessMsgRequestFailure(msgReader);
                        break;
                    // Channel messages
                    case SshConnectionMessage.ChannelOpen:
                        ProcessMsgChannelOpen(msgReader);
                        break;
                    case SshConnectionMessage.ChannelOpenConfirmation:
                        ProcessMsgChannelOpenConfirmation(msgReader);
                        break;
                    case SshConnectionMessage.ChannelOpenFailure:
                        ProcessMsgChannelOpenFailure(msgReader);
                        break;
                    case SshConnectionMessage.ChannelEof:
                        ProcessMsgChannelEof(msgReader);
                        break;
                    case SshConnectionMessage.ChannelClose:
                        ProcessMsgChannelClose(msgReader);
                        break;
                    case SshConnectionMessage.ChannelRequest:
                        ProcessMsgChannelRequest(msgReader);
                        break;
                    case SshConnectionMessage.ChannelWindowAdjust:
                        ProcessMsgChannelWindowAdjust(msgReader);
                        break;
                    case SshConnectionMessage.ChannelData:
                        ProcessMsgChannelData(msgReader);
                        break;
                    case SshConnectionMessage.ChannelExtendedData:
                        ProcessMsgChannelExtendedData(msgReader);
                        break;
                    // Unrecognised message
                    default:
                        return false;
                }
            }

            // Message was recognised.
            return true;
        }
        protected List<TerminalMode> ReadTerminalModes(byte[] encodedModes)
        {
            var termModes = new List<TerminalMode>();
            TerminalModeOpCode opCode;

            // Read modes from encoded byte stream.
            using (var streamReader = new SshStreamReader(new MemoryStream(encodedModes)))
            {
                while (true)
                {
                    opCode = (TerminalModeOpCode)streamReader.ReadByte();

                    if (opCode == TerminalModeOpCode.TtyOpEnd) break;
                    if ((byte)opCode >= 1 && (byte)opCode <= 160)
                    {
                        // Add mode to list.
                        termModes.Add(new TerminalMode(opCode, streamReader.ReadUInt32()));
                    }
                    else
                    {
                        // Undefined op code.
                        break;
                    }
                }
            }

            return termModes;
        }