public void ChannelDataMessageConstructorTest1()
{
uint localChannelNumber = 0; // TODO: Initialize to an appropriate value
byte[] data = null; // TODO: Initialize to an appropriate value
ChannelDataMessage target = new ChannelDataMessage(localChannelNumber, data);
Assert.Inconclusive("TODO: Implement code to verify target");
}
public void DefaultConstructor()
{
var target = new ChannelDataMessage();
Assert.IsNull(target.Data);
Assert.AreEqual(0, target.Offset);
Assert.AreEqual(0, target.Size);
}
public void Constructor_LocalChannelNumberAndDataAndOffsetAndSize()
{
var localChannelNumber = (uint) new Random().Next(0, int.MaxValue);
var data = new byte[4];
const int offset = 2;
const int size = 1;
var target = new ChannelDataMessage(localChannelNumber, data, offset, size);
Assert.AreSame(data, target.Data);
Assert.AreEqual(offset, target.Offset);
Assert.AreEqual(size, target.Size);
}
public void Constructor_LocalChannelNumberAndData()
{
var random = new Random();
var localChannelNumber = (uint)random.Next(0, int.MaxValue);
var data = new byte[3];
var target = new ChannelDataMessage(localChannelNumber, data);
Assert.AreSame(data, target.Data);
Assert.AreEqual(0, target.Offset);
Assert.AreEqual(data.Length, target.Size);
}
/// <summary>
/// Sends channel data message to the servers.
/// </summary>
/// <param name="message">Channel data message.</param>
/// <remarks>
/// <para>
/// When the data of the message exceeds the maximum packet size or the remote window
/// size does not allow the full message to be sent, then this method will send the
/// data in multiple chunks and will only wait for the remote window size to be adjusted
/// when its zero.
/// </para>
/// <para>
/// This is done to support SSH servers will a small window size that do not agressively
/// increase their window size. We need to take into account that there may be SSH
/// servers that only increase their window size when it has reached zero.
/// </para>
/// </remarks>
protected void SendMessage(ChannelDataMessage message)
{
// send channel messages only while channel is open
if (!this.IsOpen)
return;
var totalDataLength = message.Data.Length;
var totalDataSent = 0;
var totalBytesToSend = totalDataLength;
while (totalBytesToSend > 0)
{
var dataThatCanBeSentInMessage = GetDataLengthThatCanBeSentInMessage(totalBytesToSend);
if (dataThatCanBeSentInMessage == totalDataLength)
{
// we can send the message in one chunk
this._session.SendMessage(message);
}
else
{
// we need to send the message in multiple chunks
var dataToSend = new byte[dataThatCanBeSentInMessage];
Array.Copy(message.Data, totalDataSent, dataToSend, 0, dataThatCanBeSentInMessage);
this._session.SendMessage(new ChannelDataMessage(message.LocalChannelNumber, dataToSend));
}
totalDataSent += dataThatCanBeSentInMessage;
totalBytesToSend -= dataThatCanBeSentInMessage;
}
}
/// <summary>
/// Sends channel data message to the servers.
/// </summary>
/// <remarks>This method takes care of managing the window size.</remarks>
/// <param name="message">Channel data message.</param>
protected void SendMessage(ChannelDataMessage message)
{
// Send channel messages only while channel is open
if (!this.IsOpen)
return;
if (this.ServerWindowSize < 1)
{
// Wait for window to be adjust
this._session.WaitHandle(this._channelWindowAdjustWaitHandle);
}
this.ServerWindowSize -= (uint)message.Data.Length;
this._session.SendMessage(message);
}
/// <summary>
/// Sends a SSH_MSG_CHANNEL_DATA message with the specified payload.
/// </summary>
/// <param name="data">An array of <see cref="byte"/> containing the payload to send.</param>
/// <param name="offset">The zero-based offset in <paramref name="data"/> at which to begin taking data from.</param>
/// <param name="size">The number of bytes of <paramref name="data"/> to send.</param>
/// <remarks>
/// <para>
/// When the size of the data to send exceeds the maximum packet size or the remote window
/// size does not allow the full data to be sent, then this method will send the data in
/// multiple chunks and will wait for the remote window size to be adjusted when it's zero.
/// </para>
/// <para>
/// This is done to support SSH servers will a small window size that do not agressively
/// increase their window size. We need to take into account that there may be SSH servers
/// that only increase their window size when it has reached zero.
/// </para>
/// </remarks>
public void SendData(byte[] data, int offset, int size)
{
// send channel messages only while channel is open
if (!IsOpen)
return;
var totalBytesToSend = size;
while (totalBytesToSend > 0)
{
var sizeOfCurrentMessage = GetDataLengthThatCanBeSentInMessage(totalBytesToSend);
var channelDataMessage = new ChannelDataMessage(
RemoteChannelNumber,
data,
offset,
sizeOfCurrentMessage);
_session.SendMessage(channelDataMessage);
totalBytesToSend -= sizeOfCurrentMessage;
offset += sizeOfCurrentMessage;
}
}
/// <summary>
/// Sends channel data message to the servers.
/// </summary>
/// <remarks>This method takes care of managing the window size.</remarks>
/// <param name="message">Channel data message.</param>
protected void SendMessage(ChannelDataMessage message)
{
// Send channel messages only while channel is open
if (!this.IsOpen)
return;
var messageLength = message.Data.Length;
do
{
lock (this._serverWindowSizeLock)
{
var serverWindowSize = this.ServerWindowSize;
if (serverWindowSize < messageLength)
{
// Wait for window to be big enough for this message
this._channelServerWindowAdjustWaitHandle.Reset();
}
else
{
this.ServerWindowSize -= (uint)messageLength;
break;
}
}
// Wait for window to change
this.WaitHandle(this._channelServerWindowAdjustWaitHandle);
} while (true);
this._session.SendMessage(message);
}
public void ChannelDataMessageConstructorTest()
{
ChannelDataMessage target = new ChannelDataMessage();
Assert.Inconclusive("TODO: Implement code to verify target");
}
//public void SendData(byte[] data)
//{
// this._session.SendMessage(new ChannelDataMessage(this._channel.RemoteChannelNumber, data));
//}
public void SendData(ChannelDataMessage message)
{
this._session.SendMessage(message);
}
public void GetBytes()
{
var random = new Random();
var localChannelNumber = (uint) random.Next(0, int.MaxValue);
var data = new byte[random.Next(10, 20)];
random.NextBytes(data);
var offset = random.Next(2, 4);
var size = random.Next(5, 9);
var target = new ChannelDataMessage(localChannelNumber, data, offset, size);
var bytes = target.GetBytes();
var expectedBytesLength = 1; // Type
expectedBytesLength += 4; // LocalChannelNumber
expectedBytesLength += 4; // Data length
expectedBytesLength += size; // Data
Assert.AreEqual(expectedBytesLength, bytes.Length);
var sshDataStream = new SshDataStream(bytes);
Assert.AreEqual(ChannelDataMessage.MessageNumber, sshDataStream.ReadByte());
Assert.AreEqual(localChannelNumber, sshDataStream.ReadUInt32());
Assert.AreEqual((uint) size, sshDataStream.ReadUInt32());
var actualData = new byte[size];
sshDataStream.Read(actualData, 0, size);
Assert.IsTrue(actualData.SequenceEqual(data.Take(offset, size)));
Assert.IsTrue(sshDataStream.IsEndOfData);
}
public void Load()
{
var random = new Random();
var localChannelNumber = (uint) random.Next(0, int.MaxValue);
var data = new byte[random.Next(10, 20)];
random.NextBytes(data);
var offset = random.Next(2, 4);
var size = random.Next(5, 9);
var channelDataMessage = new ChannelDataMessage(localChannelNumber, data, offset, size);
var bytes = channelDataMessage.GetBytes();
var target = new ChannelDataMessage();
target.Load(bytes);
Assert.IsTrue(target.Data.SequenceEqual(data.Take(offset, size)));
Assert.AreEqual(0, target.Offset);
Assert.AreEqual(size, target.Size);
}