public void GetBytes() { var target = new PseudoTerminalRequestInfo(_environmentVariable, _columns, _rows, _width, _height, _terminalModeValues); var bytes = target.GetBytes(); var expectedBytesLength = 1; // WantReply expectedBytesLength += 4; // EnvironmentVariable length expectedBytesLength += _environmentVariableBytes.Length; // EnvironmentVariable expectedBytesLength += 4; // Columns expectedBytesLength += 4; // Rows expectedBytesLength += 4; // PixelWidth expectedBytesLength += 4; // PixelHeight expectedBytesLength += 4; // Length of "encoded terminal modes" expectedBytesLength += _terminalModeValues.Count*(1 + 4) + 1; // encoded terminal modes Assert.AreEqual(expectedBytesLength, bytes.Length); var sshDataStream = new SshDataStream(bytes); Assert.AreEqual(1, sshDataStream.ReadByte()); // WantReply Assert.AreEqual(_environmentVariable, sshDataStream.ReadString(Encoding.UTF8)); Assert.AreEqual(_columns, sshDataStream.ReadUInt32()); Assert.AreEqual(_rows, sshDataStream.ReadUInt32()); Assert.AreEqual(_width, sshDataStream.ReadUInt32()); Assert.AreEqual(_height, sshDataStream.ReadUInt32()); Assert.AreEqual((uint) (_terminalModeValues.Count * (1 + 4) + 1), sshDataStream.ReadUInt32()); Assert.AreEqual((int) TerminalModes.CS8, sshDataStream.ReadByte()); Assert.AreEqual(_terminalModeValues[TerminalModes.CS8], sshDataStream.ReadUInt32()); Assert.AreEqual((int) TerminalModes.ECHO, sshDataStream.ReadByte()); Assert.AreEqual(_terminalModeValues[TerminalModes.ECHO], sshDataStream.ReadUInt32()); Assert.AreEqual((int) TerminalModes.TTY_OP_END, sshDataStream.ReadByte()); Assert.IsTrue(sshDataStream.IsEndOfData); }
public void GetBytes() { var request = new SftpMkDirRequest(_protocolVersion, _requestId, _path, _encoding, null); var bytes = request.GetBytes(); var expectedBytesLength = 0; expectedBytesLength += 4; // Length expectedBytesLength += 1; // Type expectedBytesLength += 4; // RequestId expectedBytesLength += 4; // Path length expectedBytesLength += _pathBytes.Length; // Path expectedBytesLength += _attributesBytes.Length; // Attributes Assert.AreEqual(expectedBytesLength, bytes.Length); var sshDataStream = new SshDataStream(bytes); Assert.AreEqual((uint) bytes.Length - 4, sshDataStream.ReadUInt32()); Assert.AreEqual((byte) SftpMessageTypes.MkDir, sshDataStream.ReadByte()); Assert.AreEqual(_requestId, sshDataStream.ReadUInt32()); Assert.AreEqual((uint) _pathBytes.Length, sshDataStream.ReadUInt32()); var actualPath = new byte[_pathBytes.Length]; sshDataStream.Read(actualPath, 0, actualPath.Length); Assert.IsTrue(_pathBytes.SequenceEqual(actualPath)); var actualAttributes = new byte[_attributesBytes.Length]; sshDataStream.Read(actualAttributes, 0, actualAttributes.Length); Assert.IsTrue(_attributesBytes.SequenceEqual(actualAttributes)); Assert.IsTrue(sshDataStream.IsEndOfData); }
public void GetBytes() { var request = new SftpRemoveRequest(_protocolVersion, _requestId, _filename, _encoding, null); var bytes = request.GetBytes(); var expectedBytesLength = 0; #if TUNING expectedBytesLength += 4; // Length #endif expectedBytesLength += 1; // Type expectedBytesLength += 4; // RequestId expectedBytesLength += 4; // Filename length expectedBytesLength += _filenameBytes.Length; // Filename Assert.AreEqual(expectedBytesLength, bytes.Length); var sshDataStream = new SshDataStream(bytes); #if TUNING Assert.AreEqual((uint) bytes.Length - 4, sshDataStream.ReadUInt32()); #endif Assert.AreEqual((byte) SftpMessageTypes.Remove, sshDataStream.ReadByte()); Assert.AreEqual(_requestId, sshDataStream.ReadUInt32()); Assert.AreEqual((uint) _filenameBytes.Length, sshDataStream.ReadUInt32()); var actualFilename = new byte[_filenameBytes.Length]; sshDataStream.Read(actualFilename, 0, actualFilename.Length); Assert.IsTrue(_filenameBytes.SequenceEqual(actualFilename)); Assert.IsTrue(sshDataStream.IsEndOfData); }
public void GetBytes() { var request = new SftpFSetStatRequest(_protocolVersion, _requestId, _handle, _attributes, null); var bytes = request.GetBytes(); var expectedBytesLength = 0; expectedBytesLength += 4; // Length expectedBytesLength += 1; // Type expectedBytesLength += 4; // RequestId expectedBytesLength += 4; // Handle length expectedBytesLength += _handle.Length; // Handle expectedBytesLength += _attributesBytes.Length; // Attributes Assert.AreEqual(expectedBytesLength, bytes.Length); var sshDataStream = new SshDataStream(bytes); Assert.AreEqual((uint) bytes.Length - 4, sshDataStream.ReadUInt32()); Assert.AreEqual((byte) SftpMessageTypes.FSetStat, sshDataStream.ReadByte()); Assert.AreEqual(_requestId, sshDataStream.ReadUInt32()); Assert.AreEqual((uint) _handle.Length, sshDataStream.ReadUInt32()); var actualHandle = new byte[_handle.Length]; sshDataStream.Read(actualHandle, 0, actualHandle.Length); Assert.IsTrue(_handle.SequenceEqual(actualHandle)); var actualAttributes = new byte[_attributesBytes.Length]; sshDataStream.Read(actualAttributes, 0, actualAttributes.Length); Assert.IsTrue(_attributesBytes.SequenceEqual(actualAttributes)); Assert.IsTrue(sshDataStream.IsEndOfData); }
public void Load() { var target = new SftpAttrsResponse(_protocolVersion); var attributes = CreateSftpFileAttributes(); var attributesBytes = attributes.GetBytes(); var sshDataStream = new SshDataStream(4 + 1 + 4 + attributesBytes.Length); sshDataStream.Position = 4; // skip 4 bytes for SSH packet length sshDataStream.WriteByte((byte) SftpMessageTypes.Attrs); sshDataStream.Write(_responseId); sshDataStream.Write(attributesBytes, 0, attributesBytes.Length); target.Load(sshDataStream.ToArray()); Assert.IsNotNull(target.Attributes); Assert.AreEqual(_protocolVersion, target.ProtocolVersion); Assert.AreEqual(_responseId, target.ResponseId); Assert.AreEqual(SftpMessageTypes.Attrs, target.SftpMessageType); // check attributes in detail Assert.AreEqual(attributes.GroupId, target.Attributes.GroupId); Assert.AreEqual(attributes.LastWriteTime, target.Attributes.LastWriteTime); Assert.AreEqual(attributes.LastWriteTime, target.Attributes.LastWriteTime); Assert.AreEqual(attributes.UserId, target.Attributes.UserId); }
public void GetBytes() { var request = new SftpBlockRequest(_protocolVersion, _requestId, _handle, _offset, _length, _lockMask, null); var bytes = request.GetBytes(); var expectedBytesLength = 0; expectedBytesLength += 4; // Length expectedBytesLength += 1; // Type expectedBytesLength += 4; // RequestId expectedBytesLength += 4; // Handle length expectedBytesLength += _handle.Length; // Handle expectedBytesLength += 8; // Offset expectedBytesLength += 8; // Length expectedBytesLength += 4; // LockMask Assert.AreEqual(expectedBytesLength, bytes.Length); var sshDataStream = new SshDataStream(bytes); Assert.AreEqual((uint) bytes.Length - 4, sshDataStream.ReadUInt32()); Assert.AreEqual((byte) SftpMessageTypes.Block, sshDataStream.ReadByte()); Assert.AreEqual(_requestId, sshDataStream.ReadUInt32()); Assert.AreEqual((uint) _handle.Length, sshDataStream.ReadUInt32()); var actualHandle = new byte[_handle.Length]; sshDataStream.Read(actualHandle, 0, actualHandle.Length); Assert.IsTrue(_handle.SequenceEqual(actualHandle)); Assert.AreEqual(_offset, sshDataStream.ReadUInt64()); Assert.AreEqual(_length, sshDataStream.ReadUInt64()); Assert.AreEqual(_lockMask, sshDataStream.ReadUInt32()); Assert.IsTrue(sshDataStream.IsEndOfData); }
public void GetBytes() { var statusActionInvocations = new List<SftpStatusResponse>(); var nameActionInvocations = new List<SftpNameResponse>(); Action<SftpStatusResponse> statusAction = statusActionInvocations.Add; var request = new SftpRmDirRequest(_protocolVersion, _requestId, _path, _encoding, null); var bytes = request.GetBytes(); var expectedBytesLength = 0; expectedBytesLength += 4; // Length expectedBytesLength += 1; // Type expectedBytesLength += 4; // RequestId expectedBytesLength += 4; // Path length expectedBytesLength += _pathBytes.Length; // Path Assert.AreEqual(expectedBytesLength, bytes.Length); var sshDataStream = new SshDataStream(bytes); Assert.AreEqual((uint) bytes.Length - 4, sshDataStream.ReadUInt32()); Assert.AreEqual((byte) SftpMessageTypes.RmDir, sshDataStream.ReadByte()); Assert.AreEqual(_requestId, sshDataStream.ReadUInt32()); Assert.AreEqual((uint) _pathBytes.Length, sshDataStream.ReadUInt32()); var actualPath = new byte[_pathBytes.Length]; sshDataStream.Read(actualPath, 0, actualPath.Length); Assert.IsTrue(_pathBytes.SequenceEqual(actualPath)); Assert.IsTrue(sshDataStream.IsEndOfData); }
public void GetBytes() { var request = new SftpRenameRequest(_protocolVersion, _requestId, _oldPath, _newPath, _encoding, null); var bytes = request.GetBytes(); var expectedBytesLength = 0; expectedBytesLength += 4; // Length expectedBytesLength += 1; // Type expectedBytesLength += 4; // RequestId expectedBytesLength += 4; // OldPath length expectedBytesLength += _oldPathBytes.Length; // OldPath expectedBytesLength += 4; // NewPath length expectedBytesLength += _newPathBytes.Length; // NewPath Assert.AreEqual(expectedBytesLength, bytes.Length); var sshDataStream = new SshDataStream(bytes); Assert.AreEqual((uint) bytes.Length - 4, sshDataStream.ReadUInt32()); Assert.AreEqual((byte) SftpMessageTypes.Rename, sshDataStream.ReadByte()); Assert.AreEqual(_requestId, sshDataStream.ReadUInt32()); Assert.AreEqual((uint) _oldPathBytes.Length, sshDataStream.ReadUInt32()); var actualOldPath = new byte[_oldPathBytes.Length]; sshDataStream.Read(actualOldPath, 0, actualOldPath.Length); Assert.IsTrue(_oldPathBytes.SequenceEqual(actualOldPath)); Assert.AreEqual((uint) _newPathBytes.Length, sshDataStream.ReadUInt32()); var actualNewPath = new byte[_newPathBytes.Length]; sshDataStream.Read(actualNewPath, 0, actualNewPath.Length); Assert.IsTrue(_newPathBytes.SequenceEqual(actualNewPath)); Assert.IsTrue(sshDataStream.IsEndOfData); }
/// <summary> /// Writes the current message to the specified <see cref="SshDataStream"/>. /// </summary> /// <param name="stream">The <see cref="SshDataStream"/> to write the message to.</param> protected override void WriteBytes(SshDataStream stream) { const int sizeOfDataLengthBytes = 4; var startPosition = stream.Position; // skip 4 bytes for the length of the SFTP message data stream.Seek(sizeOfDataLengthBytes, SeekOrigin.Current); // write the SFTP message data to the stream base.WriteBytes(stream); // save where we were positioned when we finished writing the SSH message data var endPosition = stream.Position; // determine the length of the SSH message data var dataLength = endPosition - startPosition - sizeOfDataLengthBytes; // write the length of the SFTP message where we were positioned before we started // writing the SFTP message data stream.Position = startPosition; stream.Write((uint) dataLength); // move back to we were positioned when we finished writing the SFTP message data stream.Position = endPosition; }
public byte[] Build() { var sshDataStream = new SshDataStream(0); sshDataStream.WriteByte(KeyExchangeDhGroupExchangeGroup.MessageNumber); sshDataStream.Write(_safePrime); sshDataStream.Write(_subGroup); return sshDataStream.ToArray(); }
/// <summary> /// Loads data bytes into internal buffer. /// </summary> /// <param name="bytes">The bytes.</param> /// <param name="offset">The zero-based offset in <paramref name="bytes"/> at which to begin reading SSH data.</param> /// <param name="count">The number of bytes to load.</param> private void LoadBytes(byte[] bytes, int offset, int count) { _loadedData = bytes; _offset = offset; _count = count; _stream = new SshDataStream(bytes, _offset, count); }
/// <summary> /// Gets data bytes array. /// </summary> /// <returns> /// A <see cref="Byte"/> array representation of data structure. /// </returns> public byte[] GetBytes() { var messageLength = BufferCapacity; var capacity = messageLength != -1 ? messageLength : DefaultCapacity; var dataStream = new SshDataStream(capacity); WriteBytes(dataStream); return(dataStream.ToArray()); }
private byte[] BuildExtensions() { var sshDataStream = new SshDataStream(0); foreach (var extensionPair in _extensions) { sshDataStream.Write(extensionPair.Key, Encoding.ASCII); sshDataStream.Write(extensionPair.Value, Encoding.ASCII); } return sshDataStream.ToArray(); }
/// <summary> /// Writes the message to the specified <see cref="SshDataStream"/>. /// </summary> protected override void WriteBytes(SshDataStream stream) { var messageAttribute = GetType().GetCustomAttributes(typeof(MessageAttribute), true).FirstOrDefault() as MessageAttribute; if (messageAttribute == null) throw new SshException(string.Format(CultureInfo.CurrentCulture, "Type '{0}' is not a valid message type.", GetType().AssemblyQualifiedName)); stream.WriteByte(messageAttribute.Number); base.WriteBytes(stream); }
public byte[] Build() { var extensions = BuildExtensions(); var sshDataStream = new SshDataStream(4 + 1 + 4 + extensions.Length); sshDataStream.Write((uint)sshDataStream.Capacity - 4); sshDataStream.WriteByte((byte)SftpMessageTypes.Version); sshDataStream.Write(_version); sshDataStream.Write(extensions, 0, extensions.Length); return sshDataStream.ToArray(); }
public KeyExchangeDhGroupExchangeReplyBuilder WithHostKey(string hostKeyAlgorithm, params BigInteger[] hostKeys) { _hostKeyAlgorithm = Encoding.UTF8.GetBytes(hostKeyAlgorithm); var sshDataStream = new SshDataStream(0); foreach (var hostKey in hostKeys) sshDataStream.Write(hostKey); _hostKeys = sshDataStream.ToArray(); return this; }
public void GetReply_StatVfsReplyInfo() { var bsize = (ulong) _random.Next(0, int.MaxValue); var frsize = (ulong) _random.Next(0, int.MaxValue); var blocks = (ulong) _random.Next(0, int.MaxValue); var bfree = (ulong) _random.Next(0, int.MaxValue); var bavail = (ulong) _random.Next(0, int.MaxValue); var files = (ulong) _random.Next(0, int.MaxValue); var ffree = (ulong) _random.Next(0, int.MaxValue); var favail = (ulong) _random.Next(0, int.MaxValue); var sid = (ulong) _random.Next(0, int.MaxValue); var namemax = (ulong) _random.Next(0, int.MaxValue); #if TUNING var sshDataStream = new SshDataStream(4 + 1 + 4 + 88); sshDataStream.Position = 4; // skip 4 bytes for SSH packet length #else var sshDataStream = new SshDataStream(1 + 4 + 88); #endif sshDataStream.WriteByte((byte) SftpMessageTypes.Attrs); sshDataStream.Write(_responseId); sshDataStream.Write(bsize); sshDataStream.Write(frsize); sshDataStream.Write(blocks); sshDataStream.Write(bfree); sshDataStream.Write(bavail); sshDataStream.Write(files); sshDataStream.Write(ffree); sshDataStream.Write(favail); sshDataStream.Write(sid); sshDataStream.Write((ulong) 0x2); sshDataStream.Write(namemax); var target = new SftpExtendedReplyResponse(_protocolVersion); target.Load(sshDataStream.ToArray()); var reply = target.GetReply<StatVfsReplyInfo>(); Assert.IsNotNull(reply); var information = reply.Information; Assert.IsNotNull(information); Assert.AreEqual(bavail, information.AvailableBlocks); Assert.AreEqual(favail, information.AvailableNodes); Assert.AreEqual(frsize, information.BlockSize); Assert.AreEqual(bsize, information.FileSystemBlockSize); Assert.AreEqual(bfree, information.FreeBlocks); Assert.AreEqual(ffree, information.FreeNodes); Assert.IsFalse(information.IsReadOnly); Assert.AreEqual(namemax, information.MaxNameLenght); Assert.AreEqual(sid, information.Sid); Assert.IsFalse(information.SupportsSetUid); Assert.AreEqual(blocks, information.TotalBlocks); Assert.AreEqual(files, information.TotalNodes); }
public byte[] Build() { var sshDataStream = new SshDataStream(0); sshDataStream.WriteByte(KeyExchangeDhGroupExchangeReply.MessageNumber); sshDataStream.Write((uint)(4 + _hostKeyAlgorithm.Length + _hostKeys.Length)); sshDataStream.Write((uint) _hostKeyAlgorithm.Length); sshDataStream.Write(_hostKeyAlgorithm, 0, _hostKeyAlgorithm.Length); sshDataStream.Write(_hostKeys, 0, _hostKeys.Length); sshDataStream.Write(_f); sshDataStream.WriteBinary(_signature); return sshDataStream.ToArray(); }
/// <summary> /// Loads data bytes into internal buffer. /// </summary> /// <param name="bytes">The bytes.</param> /// <param name="offset">The zero-based offset in <paramref name="bytes"/> at which to begin reading SSH data.</param> /// <exception cref="ArgumentNullException"><paramref name="bytes"/> is null.</exception> protected void LoadBytes(byte[] bytes, int offset) { if (bytes == null) { throw new ArgumentNullException("bytes"); } _loadedData = bytes; _offset = offset; _stream = new SshDataStream(bytes); ResetReader(); }
public void Load() { var target = new SftpExtendedReplyResponse(_protocolVersion); var sshDataStream = new SshDataStream(4); sshDataStream.Write(_responseId); target.Load(sshDataStream.ToArray()); Assert.AreEqual(_protocolVersion, target.ProtocolVersion); Assert.AreEqual(_responseId, target.ResponseId); Assert.AreEqual(SftpMessageTypes.ExtendedReply, target.SftpMessageType); }
public void Load() { var target = new SftpExtendedReplyResponse(_protocolVersion); var sshDataStream = new SshDataStream(4 + 1 + 4); sshDataStream.Position = 4; // skip 4 bytes for SSH packet length sshDataStream.WriteByte((byte) SftpMessageTypes.ExtendedReply); sshDataStream.Write(_responseId); target.Load(sshDataStream.ToArray()); Assert.AreEqual(_protocolVersion, target.ProtocolVersion); Assert.AreEqual(_responseId, target.ResponseId); Assert.AreEqual(SftpMessageTypes.ExtendedReply, target.SftpMessageType); }
byte[] GetBytes() { #if TUNING var messageLength = BufferCapacity; var capacity = messageLength != -1 ? messageLength : DefaultCapacity; var dataStream = new SshDataStream(capacity); WriteBytes(dataStream); return(dataStream.ToArray()); #else _data = new List <byte>(); SaveData(); return(_data.ToArray()); #endif }
public void Load_Data() { const uint one = 123456u; const uint two = 456789u; var sshDataStream = new SshDataStream(8); sshDataStream.Write(one); sshDataStream.Write(two); var sshData = sshDataStream.ToArray(); var request = new RequestSshData(); request.Load(sshData); Assert.AreEqual(one, request.ValueOne); Assert.AreEqual(two, request.ValueTwo); }
public void Load() { var target = new SftpHandleResponse(_protocolVersion); var sshDataStream = new SshDataStream(4 + _handle.Length); sshDataStream.Write(_responseId); sshDataStream.Write((uint) _handle.Length); sshDataStream.Write(_handle, 0, _handle.Length); target.Load(sshDataStream.ToArray()); Assert.IsNotNull(target.Handle); Assert.IsTrue(target.Handle.SequenceEqual(_handle)); Assert.AreEqual(_protocolVersion, target.ProtocolVersion); Assert.AreEqual(_responseId, target.ResponseId); Assert.AreEqual(SftpMessageTypes.Handle, target.SftpMessageType); }
public void Load() { var target = new SftpDataResponse(_protocolVersion); var sshDataStream = new SshDataStream(4 + _data.Length); sshDataStream.Write(_responseId); sshDataStream.Write((uint) _data.Length); sshDataStream.Write(_data, 0, _data.Length); var sshData = sshDataStream.ToArray(); target.Load(sshData); Assert.IsNotNull(target.Data); Assert.IsTrue(target.Data.SequenceEqual(_data)); Assert.AreEqual(_protocolVersion, target.ProtocolVersion); Assert.AreEqual(_responseId, target.ResponseId); Assert.AreEqual(SftpMessageTypes.Data, target.SftpMessageType); }
public void Load() { var target = new SftpDataResponse(_protocolVersion); var sshDataStream = new SshDataStream(4 + 1 + 4 + _data.Length); sshDataStream.Position = 4; // skip 4 bytes for SSH packet length sshDataStream.WriteByte((byte)SftpMessageTypes.Attrs); sshDataStream.Write(_responseId); sshDataStream.Write((uint) _data.Length); sshDataStream.Write(_data, 0, _data.Length); target.Load(sshDataStream.ToArray()); Assert.IsNotNull(target.Data); Assert.IsTrue(target.Data.SequenceEqual(_data)); Assert.AreEqual(_protocolVersion, target.ProtocolVersion); Assert.AreEqual(_responseId, target.ResponseId); Assert.AreEqual(SftpMessageTypes.Data, target.SftpMessageType); }
public void Load() { var target = new StatVfsReplyInfo(); #if TUNING var sshDataStream = new SshDataStream(4 + 1 + 4 + 88); sshDataStream.Write((uint) (sshDataStream.Capacity - 4)); #else var sshDataStream = new SshDataStream(1 + 4 + 88); #endif sshDataStream.WriteByte((byte) SftpMessageTypes.ExtendedReply); sshDataStream.Write(_responseId); sshDataStream.Write(_bsize); sshDataStream.Write(_frsize); sshDataStream.Write(_blocks); sshDataStream.Write(_bfree); sshDataStream.Write(_bavail); sshDataStream.Write(_files); sshDataStream.Write(_ffree); sshDataStream.Write(_favail); sshDataStream.Write(_sid); sshDataStream.Write((ulong) 0x1); sshDataStream.Write(_namemax); target.Load(sshDataStream.ToArray()); Assert.IsNotNull(target.Information); var information = target.Information; Assert.AreEqual(_bavail, information.AvailableBlocks); Assert.AreEqual(_favail, information.AvailableNodes); Assert.AreEqual(_frsize, information.BlockSize); Assert.AreEqual(_bsize, information.FileSystemBlockSize); Assert.AreEqual(_bfree, information.FreeBlocks); Assert.AreEqual(_ffree, information.FreeNodes); Assert.IsTrue(information.IsReadOnly); Assert.AreEqual(_namemax, information.MaxNameLenght); Assert.AreEqual(_sid, information.Sid); Assert.IsTrue(information.SupportsSetUid); Assert.AreEqual(_blocks, information.TotalBlocks); Assert.AreEqual(_files, information.TotalNodes); }
public void Load_DataAndOffsetAndCount() { const uint one = 123456u; const uint two = 456789u; var sshDataStream = new SshDataStream(11); sshDataStream.WriteByte(0x05); sshDataStream.WriteByte(0x07); sshDataStream.WriteByte(0x0f); sshDataStream.Write(one); sshDataStream.Write(two); var sshData = sshDataStream.ToArray(); var request = new RequestSshData(); request.Load(sshData, 3, sshData.Length - 3); Assert.AreEqual(one, request.ValueOne); Assert.AreEqual(two, request.ValueTwo); }
public void Load() { var target = new SftpHandleResponse(_protocolVersion); #if TUNING var sshDataStream = new SshDataStream(4 + 1 + 4 + _handle.Length); sshDataStream.Position = 4; // skip 4 bytes for SSH packet length #else var sshDataStream = new SshDataStream(1 + 4 + _handle.Length); #endif sshDataStream.WriteByte((byte) SftpMessageTypes.Handle); sshDataStream.Write(_responseId); sshDataStream.Write((uint) _handle.Length); sshDataStream.Write(_handle, 0, _handle.Length); target.Load(sshDataStream.ToArray()); Assert.IsNotNull(target.Handle); Assert.IsTrue(target.Handle.SequenceEqual(_handle)); Assert.AreEqual(_protocolVersion, target.ProtocolVersion); Assert.AreEqual(_responseId, target.ResponseId); Assert.AreEqual(SftpMessageTypes.Handle, target.SftpMessageType); }
public void Test_KeyExchangeDhGroupExchangeRequest_GetBytes() { var request = new KeyExchangeDhGroupExchangeRequest(_minimum, _preferred, _maximum); var bytes = request.GetBytes(); var expectedBytesLength = 0; expectedBytesLength += 1; // Type expectedBytesLength += 4; // Minimum expectedBytesLength += 4; // Preferred expectedBytesLength += 4; // Maximum Assert.AreEqual(expectedBytesLength, bytes.Length); var sshDataStream = new SshDataStream(bytes); Assert.AreEqual(KeyExchangeDhGroupExchangeRequest.MessageNumber, sshDataStream.ReadByte()); Assert.AreEqual(_minimum, sshDataStream.ReadUInt32()); Assert.AreEqual(_preferred, sshDataStream.ReadUInt32()); Assert.AreEqual(_maximum, sshDataStream.ReadUInt32()); Assert.IsTrue(sshDataStream.IsEndOfData); }
public void GetBytes() { var request = new IgnoreMessage(_data); var bytes = request.GetBytes(); var expectedBytesLength = 0; expectedBytesLength += 1; // Type expectedBytesLength += 4; // Data length expectedBytesLength += _data.Length; // Data Assert.AreEqual(expectedBytesLength, bytes.Length); var sshDataStream = new SshDataStream(bytes); Assert.AreEqual(IgnoreMessage.MessageNumber, sshDataStream.ReadByte()); Assert.AreEqual((uint) _data.Length, sshDataStream.ReadUInt32()); var actualData = new byte[_data.Length]; sshDataStream.Read(actualData, 0, actualData.Length); Assert.IsTrue(_data.SequenceEqual(actualData)); Assert.IsTrue(sshDataStream.IsEndOfData); }
/// <summary> /// Writes the current message to the specified <see cref="SshDataStream"/>. /// </summary> /// <param name="stream">The <see cref="SshDataStream"/> to write the message to.</param> protected virtual void WriteBytes(SshDataStream stream) { _stream = stream; SaveData(); }
private void LoadInternal(byte[] value, int offset, int count) { _stream = new SshDataStream(value, offset, count); LoadData(); }
public byte[] Build() { var serviceName = _serviceName.ToArray(); var sshDataStream = new SshDataStream(4 + 1 + 1 + 4 + serviceName.Length); sshDataStream.Write((uint)(sshDataStream.Capacity - 4)); // packet length sshDataStream.WriteByte(0); // padding length sshDataStream.WriteByte(ServiceAcceptMessage.MessageNumber); sshDataStream.WriteBinary(serviceName); return sshDataStream.ToArray(); }
public void GetBytes() { var request = new SftpLStatRequest(_protocolVersion, _requestId, _path, _encoding, null, null); var bytes = request.GetBytes(); var expectedBytesLength = 0; #if TUNING expectedBytesLength += 4; // Length #endif expectedBytesLength += 1; // Type expectedBytesLength += 4; // RequestId expectedBytesLength += 4; // Pah length expectedBytesLength += _pathBytes.Length; // Path Assert.AreEqual(expectedBytesLength, bytes.Length); var sshDataStream = new SshDataStream(bytes); #if TUNING Assert.AreEqual((uint)bytes.Length - 4, sshDataStream.ReadUInt32()); #endif Assert.AreEqual((byte)SftpMessageTypes.LStat, sshDataStream.ReadByte()); Assert.AreEqual(_requestId, sshDataStream.ReadUInt32()); Assert.AreEqual((uint) _pathBytes.Length, sshDataStream.ReadUInt32()); var actualPath = new byte[_pathBytes.Length]; sshDataStream.Read(actualPath, 0, actualPath.Length); Assert.IsTrue(_pathBytes.SequenceEqual(actualPath)); Assert.IsTrue(sshDataStream.IsEndOfData); }
public void GetBytes() { var localChannelNumber = (uint)_random.Next(0, int.MaxValue); var initialWindowSize = (uint)_random.Next(0, int.MaxValue); var maximumPacketSize = (uint)_random.Next(0, int.MaxValue); var info = new DirectTcpipChannelInfo("host", 22, "originator", 25); var infoBytes = info.GetBytes(); var target = new ChannelOpenMessage(localChannelNumber, initialWindowSize, maximumPacketSize, info); var bytes = target.GetBytes(); var expectedBytesLength = 1; // Type expectedBytesLength += 4; // ChannelType length expectedBytesLength += target.ChannelType.Length; // ChannelType expectedBytesLength += 4; // LocalChannelNumber expectedBytesLength += 4; // InitialWindowSize expectedBytesLength += 4; // MaximumPacketSize expectedBytesLength += infoBytes.Length; // Info Assert.AreEqual(expectedBytesLength, bytes.Length); var sshDataStream = new SshDataStream(bytes); Assert.AreEqual(ChannelOpenMessage.MessageNumber, sshDataStream.ReadByte()); var actualChannelTypeLength = sshDataStream.ReadUInt32(); Assert.AreEqual((uint) target.ChannelType.Length, actualChannelTypeLength); var actualChannelType = new byte[actualChannelTypeLength]; sshDataStream.Read(actualChannelType, 0, (int) actualChannelTypeLength); Assert.IsTrue(target.ChannelType.SequenceEqual(actualChannelType)); Assert.AreEqual(localChannelNumber, sshDataStream.ReadUInt32()); Assert.AreEqual(initialWindowSize, sshDataStream.ReadUInt32()); Assert.AreEqual(maximumPacketSize, sshDataStream.ReadUInt32()); var actualInfo = new byte[infoBytes.Length]; sshDataStream.Read(actualInfo, 0, actualInfo.Length); Assert.IsTrue(infoBytes.SequenceEqual(actualInfo)); Assert.IsTrue(sshDataStream.IsEndOfData); }