Exemplo n.º 1
0
        //internal async Task AsyncReceivePacket(SSH1Packet p) {
        internal void AsyncReceivePacket(SSH1Packet p)
        {
            try {
                int len = 0, channel = 0;
                switch (p.Type)
                {
                case PacketType.SSH_SMSG_STDOUT_DATA:
                    len = SSHUtil.ReadInt32(p.Data, 0);
                    //await FindChannelEntry(_shellID)._receiver.OnData(p.Data, 4, len);
                    FindChannelEntry(_shellID)._receiver.OnData(p.Data, 4, len);
                    break;

                case PacketType.SSH_SMSG_STDERR_DATA: {
                    SSH1DataReader re = new SSH1DataReader(p.Data);
                    FindChannelEntry(_shellID)._receiver.OnExtendedData((int)PacketType.SSH_SMSG_STDERR_DATA, re.ReadString());
                }
                break;

                case PacketType.SSH_MSG_CHANNEL_DATA:
                    channel = SSHUtil.ReadInt32(p.Data, 0);
                    len     = SSHUtil.ReadInt32(p.Data, 4);
                    //await FindChannelEntry(channel)._receiver.OnData(p.Data, 8, len);
                    FindChannelEntry(channel)._receiver.OnData(p.Data, 8, len);
                    break;

                case PacketType.SSH_MSG_PORT_OPEN:
                    this.ProcessPortforwardingRequest(_eventReceiver, p);
                    break;

                case PacketType.SSH_MSG_CHANNEL_CLOSE: {
                    channel = SSHUtil.ReadInt32(p.Data, 0);
                    ISSHChannelEventReceiver r = FindChannelEntry(channel)._receiver;
                    UnregisterChannelEventReceiver(channel);
                    r.OnChannelClosed();
                }
                break;

                case PacketType.SSH_MSG_CHANNEL_CLOSE_CONFIRMATION:
                    channel = SSHUtil.ReadInt32(p.Data, 0);
                    break;

                case PacketType.SSH_MSG_DISCONNECT:
                    _eventReceiver.OnConnectionClosed();
                    break;

                case PacketType.SSH_SMSG_EXITSTATUS:
                    FindChannelEntry(_shellID)._receiver.OnChannelClosed();
                    break;

                case PacketType.SSH_MSG_DEBUG: {
                    SSH1DataReader re = new SSH1DataReader(p.Data);
                    _eventReceiver.OnDebugMessage(false, re.ReadString());
                }
                break;

                case PacketType.SSH_MSG_IGNORE: {
                    SSH1DataReader re = new SSH1DataReader(p.Data);
                    _eventReceiver.OnIgnoreMessage(re.ReadString());
                }
                break;

                case PacketType.SSH_MSG_CHANNEL_OPEN_CONFIRMATION: {
                    int local  = SSHUtil.ReadInt32(p.Data, 0);
                    int remote = SSHUtil.ReadInt32(p.Data, 4);
                    FindChannelEntry(local)._receiver.OnChannelReady();
                }
                break;

                case PacketType.SSH_SMSG_SUCCESS:
                    if (_executingShell)
                    {
                        ExecShell();
                        this.FindChannelEntry(_shellID)._receiver.OnChannelReady();
                        _executingShell = false;
                    }
                    break;

                default:
                    _eventReceiver.OnUnknownMessage((byte)p.Type, p.Data);
                    break;
                }
            }
            catch (Exception ex) {
                if (!_closed)
                {
                    _eventReceiver.OnError(ex, ex.Message);
                }
            }
        }