internal void AsyncReceivePacket(DataFragment data)
{
try {
int len = 0, channel = 0;
SSH1DataReader re = new SSH1DataReader(data);
PacketType pt = re.ReadPacketType();
switch (pt)
{
case PacketType.SSH_SMSG_STDOUT_DATA:
len = re.ReadInt32();
_channel_collection.FindChannelEntry(_shellID).Receiver.OnData(re.Image, re.Offset, len);
break;
case PacketType.SSH_SMSG_STDERR_DATA: {
_channel_collection.FindChannelEntry(_shellID).Receiver.OnExtendedData((int)PacketType.SSH_SMSG_STDERR_DATA, re.ReadString());
}
break;
case PacketType.SSH_MSG_CHANNEL_DATA:
channel = re.ReadInt32();
len = re.ReadInt32();
_channel_collection.FindChannelEntry(channel).Receiver.OnData(re.Image, re.Offset, len);
break;
case PacketType.SSH_MSG_PORT_OPEN:
ProcessPortforwardingRequest(_eventReceiver, re);
break;
case PacketType.SSH_MSG_CHANNEL_CLOSE: {
channel = re.ReadInt32();
ISSHChannelEventReceiver r = _channel_collection.FindChannelEntry(channel).Receiver;
_channel_collection.UnregisterChannelEventReceiver(channel);
r.OnChannelClosed();
}
break;
case PacketType.SSH_MSG_CHANNEL_CLOSE_CONFIRMATION:
channel = re.ReadInt32();
break;
case PacketType.SSH_MSG_DISCONNECT:
_eventReceiver.OnConnectionClosed();
break;
case PacketType.SSH_SMSG_EXITSTATUS:
_channel_collection.FindChannelEntry(_shellID).Receiver.OnChannelClosed();
break;
case PacketType.SSH_MSG_DEBUG:
_eventReceiver.OnDebugMessage(false, re.ReadString());
break;
case PacketType.SSH_MSG_IGNORE:
_eventReceiver.OnIgnoreMessage(re.ReadString());
break;
case PacketType.SSH_MSG_CHANNEL_OPEN_CONFIRMATION: {
int local = re.ReadInt32();
int remote = re.ReadInt32();
_channel_collection.FindChannelEntry(local).Receiver.OnChannelReady();
}
break;
case PacketType.SSH_SMSG_SUCCESS:
if (_executingShell)
{
ExecShell();
_channel_collection.FindChannelEntry(_shellID).Receiver.OnChannelReady();
_executingShell = false;
}
break;
default:
_eventReceiver.OnUnknownMessage((byte)pt, re.ReadAll());
break;
}
}
catch (Exception ex) {
_eventReceiver.OnError(ex);
}
}
internal void ProcessPacket(ISSHChannelEventReceiver receiver, PacketType pt, int data_length, SSH2DataReader re)
{
//NOTE: the offset of 're' is next to 'receipiant channel' field
_leftWindowSize -= data_length;
while(_leftWindowSize <= _windowSize) {
SSH2DataWriter adj = new SSH2DataWriter();
adj.WritePacketType(PacketType.SSH_MSG_CHANNEL_WINDOW_ADJUST);
adj.Write(_remoteID);
adj.Write(_windowSize);
TransmitPacket(adj.ToByteArray());
_leftWindowSize += _windowSize;
//Debug.WriteLine("Window size is adjusted to " + _leftWindowSize);
}
if(pt==PacketType.SSH_MSG_CHANNEL_WINDOW_ADJUST) {
int w = re.ReadInt32();
//Debug.WriteLine(String.Format("Window Adjust +={0}",w));
}
else if(_negotiationStatus!=0) { //when the negotiation is not completed
if(_type==ChannelType.Shell)
OpenShell(receiver, pt, re);
else if(_type==ChannelType.ForwardedLocalToRemote)
ReceivePortForwardingResponse(receiver, pt, re);
else if(_type==ChannelType.Session)
EstablishSession(receiver, pt, re);
}
else {
switch(pt) {
case PacketType.SSH_MSG_CHANNEL_DATA: {
int len = re.ReadInt32();
receiver.OnData(re.Image, re.Offset, len);
}
break;
case PacketType.SSH_MSG_CHANNEL_EXTENDED_DATA: {
int t = re.ReadInt32();
byte[] data = re.ReadString();
receiver.OnExtendedData(t, data);
}
break;
case PacketType.SSH_MSG_CHANNEL_REQUEST: {
string request = Encoding.ASCII.GetString(re.ReadString());
bool reply = re.ReadBool();
if(request=="exit-status") {
int status = re.ReadInt32();
}
else if(reply) { //we reject unknown requests including keep-alive check
SSH2DataWriter wr = new SSH2DataWriter();
wr.Write((byte)PacketType.SSH_MSG_CHANNEL_FAILURE);
wr.Write(_remoteID);
TransmitPacket(wr.ToByteArray());
}
}
break;
case PacketType.SSH_MSG_CHANNEL_EOF:
receiver.OnChannelEOF();
break;
case PacketType.SSH_MSG_CHANNEL_CLOSE:
_connection.UnregisterChannelEventReceiver(_localID);
receiver.OnChannelClosed();
break;
case PacketType.SSH_MSG_CHANNEL_FAILURE:
case PacketType.SSH_MSG_CHANNEL_SUCCESS:
receiver.OnMiscPacket((byte)pt, re.Image, re.Offset, re.Rest);
break;
default:
receiver.OnMiscPacket((byte)pt, re.Image, re.Offset, re.Rest);
Debug.WriteLine("Unknown Packet "+pt);
break;
}
}
}
private void ProcessChannelLocalData(ISSHChannelEventReceiver receiver, PacketType pt, SSH2DataReader re) {
switch(pt) {
case PacketType.SSH_MSG_CHANNEL_DATA: {
int len = re.ReadInt32();
receiver.OnData(re.Image, re.Offset, len);
}
break;
case PacketType.SSH_MSG_CHANNEL_EXTENDED_DATA: {
int t = re.ReadInt32();
byte[] data = re.ReadString();
receiver.OnExtendedData(t, data);
}
break;
case PacketType.SSH_MSG_CHANNEL_REQUEST: {
string request = Encoding.ASCII.GetString(re.ReadString());
bool reply = re.ReadBool();
if(request=="exit-status") {
int status = re.ReadInt32();
}
else if(reply) { //we reject unknown requests including keep-alive check
SSH2DataWriter wr = new SSH2DataWriter();
wr.WritePacketType(PacketType.SSH_MSG_CHANNEL_FAILURE);
wr.Write(_remoteID);
TransmitPayload(wr.ToByteArray());
}
}
break;
case PacketType.SSH_MSG_CHANNEL_EOF:
receiver.OnChannelEOF();
break;
case PacketType.SSH_MSG_CHANNEL_CLOSE:
_connection.ChannelCollection.UnregisterChannelEventReceiver(_localID);
receiver.OnChannelClosed();
break;
case PacketType.SSH_MSG_CHANNEL_FAILURE:
receiver.OnMiscPacket((byte)pt, re.Image, re.Offset, re.Rest);
break;
default:
receiver.OnMiscPacket((byte)pt, re.Image, re.Offset, re.Rest);
Debug.WriteLine("Unknown Packet "+pt);
break;
}
}
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);
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);
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);
}
}
}
public void OnClosed()
{
_handler.OnChannelClosed();
}
private void ProcessChannelLocalData(ISSHChannelEventReceiver receiver, SSH2PacketType pt, SSH2DataReader re)
{
switch (pt) {
case SSH2PacketType.SSH_MSG_CHANNEL_DATA: {
int len = re.ReadInt32();
DataFragment frag = re.GetRemainingDataView(len);
receiver.OnData(frag.Data, frag.Offset, frag.Length);
}
break;
case SSH2PacketType.SSH_MSG_CHANNEL_EXTENDED_DATA: {
int t = re.ReadInt32();
byte[] data = re.ReadByteString();
receiver.OnExtendedData(t, data);
}
break;
case SSH2PacketType.SSH_MSG_CHANNEL_REQUEST: {
string request = re.ReadString();
bool reply = re.ReadBool();
if (request == "exit-status") {
int status = re.ReadInt32();
}
else if (reply) { //we reject unknown requests including keep-alive check
Transmit(
0,
new SSH2Packet(SSH2PacketType.SSH_MSG_CHANNEL_FAILURE)
.WriteInt32(_remoteID)
);
}
}
break;
case SSH2PacketType.SSH_MSG_CHANNEL_EOF:
receiver.OnChannelEOF();
break;
case SSH2PacketType.SSH_MSG_CHANNEL_CLOSE:
_connection.ChannelCollection.UnregisterChannelEventReceiver(_localID);
receiver.OnChannelClosed();
break;
case SSH2PacketType.SSH_MSG_CHANNEL_FAILURE: {
DataFragment frag = re.GetRemainingDataView();
receiver.OnMiscPacket((byte)pt, frag.Data, frag.Offset, frag.Length);
}
break;
default: {
DataFragment frag = re.GetRemainingDataView();
receiver.OnMiscPacket((byte)pt, frag.Data, frag.Offset, frag.Length);
}
Debug.WriteLine("Unknown Packet " + pt);
break;
}
}
