public byte[] GetDataToWrite() { if (IsMagicBlock) { var length = BlockMagic.Length + // block magic 4 + // plugin name length PluginName.Length + // plugin name itself BlockData.Length; using (var ms = new MemoryStream()) { ms.Write(LittleEndian.GetBytes(length), 0, 4); ms.Write(BlockMagic, 0, BlockMagic.Length); ms.Write(BigEndian.GetBytes(PluginName.Length), 0, 4); ms.Write(PluginName, 0, PluginName.Length); ms.Write(BlockData, 0, BlockData.Length); return(ms.ToByteArray()); } } using (var ms = new MemoryStream()) { var length2 = BlockData.Length; ms.Write(LittleEndian.GetBytes(length2), 0, 4); ms.Write(BlockData, 0, BlockData.Length); ms.Write(new byte[] { 0xDE, 0xAD, 0xBE, 0xEF }, 0, 4); return(ms.ToByteArray()); } }
/// <summary> /// Generates binary image of the <see cref="MetadataRecordComposedFields"/> and copies it into the given buffer, for <see cref="BinaryLength"/> bytes. /// </summary> /// <param name="buffer">Buffer used to hold generated binary image of the source object.</param> /// <param name="startIndex">0-based starting index in the <paramref name="buffer"/> to start writing.</param> /// <returns>The number of bytes written to the <paramref name="buffer"/>.</returns> /// <exception cref="ArgumentNullException"><paramref name="buffer"/> is null.</exception> /// <exception cref="ArgumentOutOfRangeException"> /// <paramref name="startIndex"/> or <see cref="BinaryLength"/> is less than 0 -or- /// <paramref name="startIndex"/> and <see cref="BinaryLength"/> will exceed <paramref name="buffer"/> length. /// </exception> public virtual int GenerateBinaryImage(byte[] buffer, int startIndex) { int length = BinaryLength; buffer.ValidateParameters(startIndex, length); Buffer.BlockCopy(LittleEndian.GetBytes(m_highAlarm), 0, buffer, startIndex, 4); Buffer.BlockCopy(LittleEndian.GetBytes(m_lowAlarm), 0, buffer, startIndex + 4, 4); Buffer.BlockCopy(LittleEndian.GetBytes(m_highRange), 0, buffer, startIndex + 8, 4); Buffer.BlockCopy(LittleEndian.GetBytes(m_lowRange), 0, buffer, startIndex + 12, 4); Buffer.BlockCopy(LittleEndian.GetBytes(m_lowWarning), 0, buffer, startIndex + 16, 4); Buffer.BlockCopy(LittleEndian.GetBytes(m_highWarning), 0, buffer, startIndex + 20, 4); Buffer.BlockCopy(LittleEndian.GetBytes(m_displayDigits), 0, buffer, startIndex + 24, 4); for (int i = 0; i < m_inputPointers.Count; i++) { Buffer.BlockCopy(LittleEndian.GetBytes(m_inputPointers[i]), 0, buffer, startIndex + 28 + (i * 4), 4); } Buffer.BlockCopy(Encoding.ASCII.GetBytes(m_engineeringUnits.PadRight(24).TruncateRight(24)), 0, buffer, startIndex + 76, 24); Buffer.BlockCopy(Encoding.ASCII.GetBytes(m_equation.PadRight(256).TruncateRight(256)), 0, buffer, startIndex + 100, 256); Buffer.BlockCopy(LittleEndian.GetBytes(m_compressionLimit), 0, buffer, startIndex + 356, 4); return(length); }
/// <summary> /// Computes the checksum. /// </summary> /// <returns></returns> public byte[] ComputeChecksum() { var checksum = _bytes.GetChecksum32(0, 106); checksum = _bytes.GetChecksum32(108, 4, checksum); checksum = _bytes.GetChecksum32(113, (int)(BytesPerSector.Value * 11 - 113), checksum); return(LittleEndian.GetBytes(checksum)); }
public virtual byte[] GetDataToWrite() { var parameterBytes = GetParameters(); var blockData = GetBlockDataToWrite(); byte[] midiData = new byte[0]; byte[] endChunk; using (var endChunkStream = new MemoryStream()) { var endChunkData = GetEndChunk(); endChunkStream.Write(endChunkData, 0, endChunkData.Length); if (IncludePatchNameAtEnd) { var patchEndName = GetCompiledEndPatchName(); endChunkStream.Write(patchEndName, 0, patchEndName.Length); } endChunk = endChunkStream.ToByteArray(); } var totalLength = parameterBytes.Length + blockData.Length + endChunk.Length; // end chunk if (IncludeMidi) { midiData = MidiBlock.GetDataToWrite(); totalLength += midiData.Length; } var ms = new MemoryStream(); // total length ms.Write(LittleEndian.GetBytes(totalLength), 0, 4); // Fill up for (var i = 0; i < 12; i++) { ms.WriteByte(0); } ms.Write(parameterBytes, 0, parameterBytes.Length); ms.Write(blockData, 0, blockData.Length); if (IncludeMidi) { ms.Write(midiData, 0, midiData.Length); } ms.Write(endChunk, 0, endChunk.Length); var data = ms.ToByteArray(); ms.Close(); return(data); }
/// <summary> /// Generates a binary representation of this <see cref="RiffChunk"/> and copies it into the given buffer. /// </summary> /// <param name="buffer">Buffer used to hold generated binary image of the source object.</param> /// <param name="startIndex">0-based starting index in the <paramref name="buffer"/> to start writing.</param> /// <returns>The number of bytes written to the <paramref name="buffer"/>.</returns> /// <exception cref="ArgumentNullException"><paramref name="buffer"/> is null.</exception> /// <exception cref="ArgumentOutOfRangeException"> /// <paramref name="startIndex"/> or <see cref="ISupportBinaryImage.BinaryLength"/> is less than 0 -or- /// <paramref name="startIndex"/> and <see cref="ISupportBinaryImage.BinaryLength"/> will exceed <paramref name="buffer"/> length. /// </exception> public virtual int GenerateBinaryImage(byte[] buffer, int startIndex) { buffer.ValidateParameters(startIndex, FixedLength); Buffer.BlockCopy(Encoding.ASCII.GetBytes(TypeID), 0, buffer, 0, 4); Buffer.BlockCopy(LittleEndian.GetBytes(ChunkSize), 0, buffer, 4, 4); return(FixedLength); }
public static void Main111(string[] args) { const string drive = "X:"; // label var driveInfo = new DriveInfo(drive); driveInfo.VolumeLabel = DiskContent.VolumeLabel; // long contiguous file using (var fc = File.Create(Path.Combine(drive, DiskContent.LongContiguousFileName))) { for (ulong offset = 0; offset < DiskContent.LongFileSize; offset += sizeof(ulong)) { var b = LittleEndian.GetBytes(DiskContent.GetLongContiguousFileNameOffsetValue(offset)); fc.Write(b, 0, b.Length); } } // long sparse files const uint chunks = 1u << 10; for (ulong offsetBase = 0; offsetBase < DiskContent.LongFileSize; offsetBase += chunks) { using (var fs1 = File.OpenWrite(Path.Combine(drive, DiskContent.LongSparseFile1Name))) using (var fs2 = File.OpenWrite(Path.Combine(drive, DiskContent.LongSparseFile2Name))) { fs1.Seek(0, SeekOrigin.End); fs2.Seek(0, SeekOrigin.End); for (ulong subOffset = 0; subOffset < chunks; subOffset += sizeof(ulong)) { var offset = offsetBase + subOffset; var b1 = LittleEndian.GetBytes(DiskContent.GetLongSparseFile1NameOffsetValue(offset)); fs1.Write(b1, 0, b1.Length); var b2 = LittleEndian.GetBytes(DiskContent.GetLongSparseFile2NameOffsetValue(offset)); fs2.Write(b2, 0, b2.Length); } } } // An empty folder Directory.CreateDirectory(Path.Combine(drive, DiskContent.EmptyRootFolderFileName)); // A folder full of garbage var longDirectoryPath = Path.Combine(drive, DiskContent.LongFolderFileName); Directory.CreateDirectory(longDirectoryPath); for (int subFileIndex = 0; subFileIndex < DiskContent.LongFolderEntriesCount; subFileIndex++) { var path = Path.Combine(longDirectoryPath, Guid.NewGuid().ToString("N")); using (var t = File.CreateText(path)) { t.WriteLine(subFileIndex); } } }
/// <summary> /// Generates binary image of the <see cref="PacketType5"/> and copies it into the given buffer, for <see cref="BinaryLength"/> bytes. /// </summary> /// <param name="buffer">Buffer used to hold generated binary image of the source object.</param> /// <param name="startIndex">0-based starting index in the <paramref name="buffer"/> to start writing.</param> /// <returns>The number of bytes written to the <paramref name="buffer"/>.</returns> /// <exception cref="ArgumentNullException"><paramref name="buffer"/> is null.</exception> /// <exception cref="ArgumentOutOfRangeException"> /// <paramref name="startIndex"/> or <see cref="BinaryLength"/> is less than 0 -or- /// <paramref name="startIndex"/> and <see cref="BinaryLength"/> will exceed <paramref name="buffer"/> length. /// </exception> public override int GenerateBinaryImage(byte[] buffer, int startIndex) { int length = BinaryLength; buffer.ValidateParameters(startIndex, length); Buffer.BlockCopy(LittleEndian.GetBytes(TypeID), 0, buffer, startIndex, 2); return(length); }
/// <summary> /// Creates the first node and set it to root. /// </summary> TreeNode <K, V> CreateFirstRoot() { // Create the first block that refers to the next block which is id(2). // Due to the design of RecordStorage, creating the very first block will result in creating two, // one for the special #0 (deletion marker) and the other which was asked to create. recordStorage.Create(LittleEndian.GetBytes(2U)); // Creating a new node after above should make this block's id 2. return(Create(null, null)); }
private byte[] GetCompiledEndPatchName() { using (var ms = new MemoryStream()) { ms.Write(LittleEndian.GetBytes(PatchName.Length + 1), 0, 4); ms.Write(PatchName, 0, PatchName.Length); ms.WriteByte(0); return(ms.ToByteArray()); } }
/// <summary> /// Generates binary image of the <see cref="ArchiveDataBlockPointer"/> and copies it into the given buffer, for <see cref="BinaryLength"/> bytes. /// </summary> /// <param name="buffer">Buffer used to hold generated binary image of the source object.</param> /// <param name="startIndex">0-based starting index in the <paramref name="buffer"/> to start writing.</param> /// <returns>The number of bytes written to the <paramref name="buffer"/>.</returns> /// <exception cref="ArgumentNullException"><paramref name="buffer"/> is null.</exception> /// <exception cref="ArgumentOutOfRangeException"> /// <paramref name="startIndex"/> or <see cref="BinaryLength"/> is less than 0 -or- /// <paramref name="startIndex"/> and <see cref="BinaryLength"/> will exceed <paramref name="buffer"/> length. /// </exception> public int GenerateBinaryImage(byte[] buffer, int startIndex) { int length = BinaryLength; buffer.ValidateParameters(startIndex, length); Buffer.BlockCopy(LittleEndian.GetBytes(m_historianID), 0, buffer, startIndex, 4); Buffer.BlockCopy(LittleEndian.GetBytes((double)m_startTime.Value), 0, buffer, startIndex + 4, 8); return(length); }
/// <summary> /// Generates binary image of the <see cref="MetadataRecordConstantFields"/> and copies it into the given buffer, for <see cref="BinaryLength"/> bytes. /// </summary> /// <param name="buffer">Buffer used to hold generated binary image of the source object.</param> /// <param name="startIndex">0-based starting index in the <paramref name="buffer"/> to start writing.</param> /// <returns>The number of bytes written to the <paramref name="buffer"/>.</returns> /// <exception cref="ArgumentNullException"><paramref name="buffer"/> is null.</exception> /// <exception cref="ArgumentOutOfRangeException"> /// <paramref name="startIndex"/> or <see cref="BinaryLength"/> is less than 0 -or- /// <paramref name="startIndex"/> and <see cref="BinaryLength"/> will exceed <paramref name="buffer"/> length. /// </exception> public virtual int GenerateBinaryImage(byte[] buffer, int startIndex) { int length = BinaryLength; buffer.ValidateParameters(startIndex, length); Buffer.BlockCopy(LittleEndian.GetBytes(m_value), 0, buffer, startIndex, 4); Buffer.BlockCopy(LittleEndian.GetBytes(m_displayDigits), 0, buffer, startIndex + 4, 4); return(length); }
/// <summary> /// Generates binary image of the <see cref="StateRecordSummary"/> and copies it into the given buffer, for <see cref="BinaryLength"/> bytes. /// </summary> /// <param name="buffer">Buffer used to hold generated binary image of the source object.</param> /// <param name="startIndex">0-based starting index in the <paramref name="buffer"/> to start writing.</param> /// <returns>The number of bytes written to the <paramref name="buffer"/>.</returns> /// <exception cref="ArgumentNullException"><paramref name="buffer"/> is null.</exception> /// <exception cref="ArgumentOutOfRangeException"> /// <paramref name="startIndex"/> or <see cref="BinaryLength"/> is less than 0 -or- /// <paramref name="startIndex"/> and <see cref="BinaryLength"/> will exceed <paramref name="buffer"/> length. /// </exception> public int GenerateBinaryImage(byte[] buffer, int startIndex) { int length = BinaryLength; buffer.ValidateParameters(startIndex, length); Buffer.BlockCopy(LittleEndian.GetBytes(m_historianID), 0, buffer, startIndex, 4); m_currentData.GenerateBinaryImage(buffer, startIndex + 4); return(length); }
public override void WriteData(Stream target) { byte[] buffer = new byte[m_headerLength]; Buffer.BlockCopy(Encoding.ASCII.GetBytes(TypeID), 0, buffer, 0, 4); kontaktSound.WriteChunk(); Buffer.BlockCopy(LittleEndian.GetBytes(kontaktSound.Chunk.Length + 4), 0, buffer, 4, 4); Buffer.BlockCopy(Encoding.ASCII.GetBytes(FileFormat), 0, buffer, 8, 4); target.Write(buffer, 0, 12); }
/// <summary> /// Builds a compressed payload from the current content's data. /// </summary> /// <param name="opcode">The packet's opcode.</param> /// <returns>A new compressed payload.</returns> public byte[] GetCompressedPayload(short opcode) { byte[] compressedData = ZLib.CompressData(_contentData); byte[] packetId = BigEndian.GetBytes(opcode); byte[] size = BigEndian.GetBytes(compressedData.Length + sizeof(int)); byte[] compressionFlag = { 1 }; // true byte[] decompressedSize = LittleEndian.GetBytes(_contentData.Length); byte[] padding = { 0, 0, 0, 0 }; return(Sequence.Concat(packetId, size, compressionFlag, decompressedSize, compressedData, padding)); }
/// <summary> /// Generates binary image of the <see cref="ArchiveDataPoint"/> and copies it into the given buffer, for <see cref="BinaryLength"/> bytes. /// </summary> /// <param name="buffer">Buffer used to hold generated binary image of the source object.</param> /// <param name="startIndex">0-based starting index in the <paramref name="buffer"/> to start writing.</param> /// <returns>The number of bytes written to the <paramref name="buffer"/>.</returns> /// <exception cref="ArgumentNullException"><paramref name="buffer"/> is null.</exception> /// <exception cref="ArgumentOutOfRangeException"> /// <paramref name="startIndex"/> or <see cref="BinaryLength"/> is less than 0 -or- /// <paramref name="startIndex"/> and <see cref="BinaryLength"/> will exceed <paramref name="buffer"/> length. /// </exception> public virtual int GenerateBinaryImage(byte[] buffer, int startIndex) { int length = BinaryLength; buffer.ValidateParameters(startIndex, length); Buffer.BlockCopy(LittleEndian.GetBytes((int)m_time.Value), 0, buffer, startIndex, 4); Buffer.BlockCopy(LittleEndian.GetBytes((short)m_flags), 0, buffer, startIndex + 4, 2); Buffer.BlockCopy(LittleEndian.GetBytes(m_value), 0, buffer, startIndex + 6, 4); return(length); }
public override void WriteChunk() { MemoryStream ms = new MemoryStream(); byte[] tmpChunk = PresetData; Chunk = new byte[tmpChunk.Length + 4]; ms.Write(LittleEndian.GetBytes(Version), 0, 4); ms.Write(tmpChunk, 0, tmpChunk.Length); Chunk = ms.ToArray(); ChunkSize = Chunk.Length; }
public static int DecodeValueAsInt(byte[] data, int length, int bitSize) { uint tmp = 0; for (var i = 0; i < length; i++) { tmp = (tmp << bitSize) ^ data[i]; } var bTmp = LittleEndian.GetBytes(tmp); return(LittleEndian.ToInt32(bTmp, 0)); }
/// <summary> /// Generates binary image of the <see cref="MetadataRecordDigitalFields"/> and copies it into the given buffer, for <see cref="BinaryLength"/> bytes. /// </summary> /// <param name="buffer">Buffer used to hold generated binary image of the source object.</param> /// <param name="startIndex">0-based starting index in the <paramref name="buffer"/> to start writing.</param> /// <returns>The number of bytes written to the <paramref name="buffer"/>.</returns> /// <exception cref="ArgumentNullException"><paramref name="buffer"/> is null.</exception> /// <exception cref="ArgumentOutOfRangeException"> /// <paramref name="startIndex"/> or <see cref="BinaryLength"/> is less than 0 -or- /// <paramref name="startIndex"/> and <see cref="BinaryLength"/> will exceed <paramref name="buffer"/> length. /// </exception> public virtual int GenerateBinaryImage(byte[] buffer, int startIndex) { int length = BinaryLength; buffer.ValidateParameters(startIndex, length); Buffer.BlockCopy(Encoding.ASCII.GetBytes(m_setDescription.PadRight(24).TruncateRight(24)), 0, buffer, startIndex, 24); Buffer.BlockCopy(Encoding.ASCII.GetBytes(m_clearDescription.PadRight(24).TruncateRight(24)), 0, buffer, startIndex + 24, 24); Buffer.BlockCopy(LittleEndian.GetBytes(m_alarmState), 0, buffer, startIndex + 48, 4); Buffer.BlockCopy(LittleEndian.GetBytes(m_alarmDelay), 0, buffer, startIndex + 52, 4); return(length); }
public static MemoryStream WriteVC2(string pluginData) { var ms = new MemoryStream(); ms.Write(new byte[] { 0x56, 0x43, 0x32, 0x21 }, 0, 4); var data = Encoding.UTF8.GetBytes(pluginData); ms.Write(LittleEndian.GetBytes(data.Length), 0, 4); ms.Write(data, 0, data.Length); ms.WriteByte(0); return(ms); }
/// <summary> /// Generates binary image of the <see cref="PacketType101DataPoint"/> and copies it into the given buffer, for <see cref="BinaryLength"/> bytes. /// </summary> /// <param name="buffer">Buffer used to hold generated binary image of the source object.</param> /// <param name="startIndex">0-based starting index in the <paramref name="buffer"/> to start writing.</param> /// <returns>The number of bytes written to the <paramref name="buffer"/>.</returns> /// <exception cref="ArgumentNullException"><paramref name="buffer"/> is null.</exception> /// <exception cref="ArgumentOutOfRangeException"> /// <paramref name="startIndex"/> or <see cref="BinaryLength"/> is less than 0 -or- /// <paramref name="startIndex"/> and <see cref="BinaryLength"/> will exceed <paramref name="buffer"/> length. /// </exception> public override int GenerateBinaryImage(byte[] buffer, int startIndex) { int length = BinaryLength; buffer.ValidateParameters(startIndex, length); Buffer.BlockCopy(LittleEndian.GetBytes(HistorianID), 0, buffer, startIndex, 4); Buffer.BlockCopy(LittleEndian.GetBytes((int)Time.Value), 0, buffer, startIndex + 4, 4); Buffer.BlockCopy(LittleEndian.GetBytes((short)Flags), 0, buffer, startIndex + 8, 2); Buffer.BlockCopy(LittleEndian.GetBytes(Value), 0, buffer, startIndex + 10, 4); return(length); }
/// <summary> /// Generates binary image of the <see cref="MetadataRecord"/> and copies it into the given buffer, for <see cref="BinaryLength"/> bytes. /// </summary> /// <param name="buffer">Buffer used to hold generated binary image of the source object.</param> /// <param name="startIndex">0-based starting index in the <paramref name="buffer"/> to start writing.</param> /// <returns>The number of bytes written to the <paramref name="buffer"/>.</returns> /// <exception cref="ArgumentNullException"><paramref name="buffer"/> is null.</exception> /// <exception cref="ArgumentOutOfRangeException"> /// <paramref name="startIndex"/> or <see cref="BinaryLength"/> is less than 0 -or- /// <paramref name="startIndex"/> and <see cref="BinaryLength"/> will exceed <paramref name="buffer"/> length. /// </exception> public virtual int GenerateBinaryImage(byte[] buffer, int startIndex) { int length = BinaryLength; buffer.ValidateParameters(startIndex, length); // Construct the binary IP buffer for this event Buffer.BlockCopy(Encoding.ASCII.GetBytes(m_remarks.PadRight(512).TruncateRight(512)), 0, buffer, startIndex, 512); Buffer.BlockCopy(Encoding.ASCII.GetBytes(m_hardwareInfo.PadRight(512).TruncateRight(512)), 0, buffer, startIndex + 512, 512); Buffer.BlockCopy(Encoding.ASCII.GetBytes(m_emailAddresses.PadRight(512).TruncateRight(512)), 0, buffer, startIndex + 1024, 512); Buffer.BlockCopy(Encoding.ASCII.GetBytes(m_description.PadRight(80).TruncateRight(80)), 0, buffer, startIndex + 1536, 80); Buffer.BlockCopy(Encoding.ASCII.GetBytes(m_currentData.PadRight(80).TruncateRight(80)), 0, buffer, startIndex + 1616, 80); Buffer.BlockCopy(Encoding.ASCII.GetBytes(m_name.PadRight(40).TruncateRight(40)), 0, buffer, startIndex + 1696, 40); Buffer.BlockCopy(Encoding.ASCII.GetBytes(m_synonym1.PadRight(40).TruncateRight(40)), 0, buffer, startIndex + 1736, 40); Buffer.BlockCopy(Encoding.ASCII.GetBytes(m_synonym2.PadRight(40).TruncateRight(40)), 0, buffer, startIndex + 1776, 40); Buffer.BlockCopy(Encoding.ASCII.GetBytes(m_synonym3.PadRight(40).TruncateRight(40)), 0, buffer, startIndex + 1816, 40); Buffer.BlockCopy(Encoding.ASCII.GetBytes(m_pagerNumbers.PadRight(40).TruncateRight(40)), 0, buffer, startIndex + 1856, 40); Buffer.BlockCopy(Encoding.ASCII.GetBytes(m_phoneNumbers.PadRight(40).TruncateRight(40)), 0, buffer, startIndex + 1896, 40); Buffer.BlockCopy(Encoding.ASCII.GetBytes(m_plantCode.PadRight(24).TruncateRight(24)), 0, buffer, startIndex + 1936, 24); Buffer.BlockCopy(Encoding.ASCII.GetBytes(m_system.PadRight(24).TruncateRight(24)), 0, buffer, startIndex + 1960, 24); Buffer.BlockCopy(Encoding.ASCII.GetBytes(m_emailTime.PadRight(40).TruncateRight(40)), 0, buffer, startIndex + 1984, 40); Buffer.BlockCopy(LittleEndian.GetBytes(m_scanRate), 0, buffer, startIndex + 2104, 4); Buffer.BlockCopy(LittleEndian.GetBytes(m_unitNumber), 0, buffer, startIndex + 2108, 4); Buffer.BlockCopy(LittleEndian.GetBytes(m_securityFlags.Value), 0, buffer, startIndex + 2112, 4); Buffer.BlockCopy(LittleEndian.GetBytes(m_generalFlags.Value), 0, buffer, startIndex + 2116, 4); Buffer.BlockCopy(LittleEndian.GetBytes(m_alarmFlags.Value), 0, buffer, startIndex + 2120, 4); Buffer.BlockCopy(LittleEndian.GetBytes(m_compressionMinTime), 0, buffer, startIndex + 2124, 4); Buffer.BlockCopy(LittleEndian.GetBytes(m_compressionMaxTime), 0, buffer, startIndex + 2128, 4); Buffer.BlockCopy(LittleEndian.GetBytes(m_sourceID), 0, buffer, startIndex + 2132, 4); switch (m_generalFlags.DataType) { case DataType.Analog: m_analogFields.GenerateBinaryImage(buffer, startIndex + 2152); break; case DataType.Digital: m_digitalFields.GenerateBinaryImage(buffer, startIndex + 2152); break; case DataType.Composed: m_composedFields.GenerateBinaryImage(buffer, startIndex + 2152); break; case DataType.Constant: m_constantFields.GenerateBinaryImage(buffer, startIndex + 2152); break; } return(length); }
/// <summary> /// Initializes a new instance of OutPacket from the given payload data, crypto handler, auth handler, prefix and count. /// </summary> /// <param name="payload">The ready payload data.</param> /// <param name="crypto">The crypto handler to be used.</param> /// <param name="auth">The auth handler to be used.</param> /// <param name="prefix">The packet's prefix.</param> /// <param name="count">The packet's count.</param> public OutPacket(byte[] payload, CryptoHandler crypto, AuthHandler auth, short prefix, int count) { byte[] packetPrefix = LittleEndian.GetBytes(prefix); byte[] packetCount = LittleEndian.GetBytes(count); byte[] iv = Generate.IV(); byte[] encryptedData = crypto.EncryptPacket(payload, iv); byte[] size = LittleEndian.GetBytes(Convert.ToInt16(16 + encryptedData.Length + 10)); byte[] authData = Sequence.Concat(packetPrefix, packetCount, iv, encryptedData); byte[] hmac = auth.GetHmac(authData); PacketData = Sequence.Concat(size, authData, hmac); }
/// <summary> /// Builds a compressed payload from the current content's data. /// </summary> /// <param name="id">The packet's id.</param> /// <returns>A new compressed payload.</returns> public byte[] GetCompressedPayload(CenterOpcodes oId) { short id = (short)oId; byte[] compressedData = ZLib.CompressData(Data); byte[] packetId = BigEndian.GetBytes(id); byte[] size = BigEndian.GetBytes(compressedData.Length + 4); byte[] compressionFlag = { 1 }; // true byte[] decompressedSize = LittleEndian.GetBytes(Data.Length); byte[] padding = { 0, 0, 0 }; return(Sequence.Concat(packetId, size, compressionFlag, decompressedSize, compressedData, padding)); }
/// <summary> /// Generates binary image of the <see cref="PacketType1"/> and copies it into the given buffer, for <see cref="BinaryLength"/> bytes. /// </summary> /// <param name="buffer">Buffer used to hold generated binary image of the source object.</param> /// <param name="startIndex">0-based starting index in the <paramref name="buffer"/> to start writing.</param> /// <returns>The number of bytes written to the <paramref name="buffer"/>.</returns> /// <exception cref="ArgumentNullException"><paramref name="buffer"/> is null.</exception> /// <exception cref="ArgumentOutOfRangeException"> /// <paramref name="startIndex"/> or <see cref="BinaryLength"/> is less than 0 -or- /// <paramref name="startIndex"/> and <see cref="BinaryLength"/> will exceed <paramref name="buffer"/> length. /// </exception> public override int GenerateBinaryImage(byte[] buffer, int startIndex) { int length = BinaryLength; buffer.ValidateParameters(startIndex, length); Buffer.BlockCopy(LittleEndian.GetBytes(TypeID), 0, buffer, startIndex, 2); Buffer.BlockCopy(LittleEndian.GetBytes(m_historianID), 0, buffer, startIndex + 2, 4); Buffer.BlockCopy(LittleEndian.GetBytes(m_time.Value), 0, buffer, startIndex + 6, 8); Buffer.BlockCopy(LittleEndian.GetBytes((int)m_quality), 0, buffer, startIndex + 14, 4); Buffer.BlockCopy(LittleEndian.GetBytes(m_value), 0, buffer, startIndex + 18, 4); return(length); }
/// <summary> /// Generates binary image of the <see cref="FixedTableRegion"/> and copies it into the given buffer, for <see cref="BinaryLength"/> bytes. /// </summary> /// <param name="buffer">Buffer used to hold generated binary image of the source object.</param> /// <param name="startIndex">0-based starting index in the <paramref name="buffer"/> to start writing.</param> /// <returns>The number of bytes written to the <paramref name="buffer"/>.</returns> /// <exception cref="ArgumentNullException"><paramref name="buffer"/> is null.</exception> /// <exception cref="ArgumentOutOfRangeException"> /// <paramref name="startIndex"/> or <see cref="BinaryLength"/> is less than 0 -or- /// <paramref name="startIndex"/> and <see cref="BinaryLength"/> will exceed <paramref name="buffer"/> length. /// </exception> public int GenerateBinaryImage(byte[] buffer, int startIndex) { int length = BinaryLength; buffer.ValidateParameters(startIndex, length); Buffer.BlockCopy(LittleEndian.GetBytes(m_parent.m_fileStartTime.Value), 0, buffer, startIndex, 8); Buffer.BlockCopy(LittleEndian.GetBytes(m_parent.m_fileEndTime.Value), 0, buffer, startIndex + 8, 8); Buffer.BlockCopy(LittleEndian.GetBytes(m_parent.m_dataPointsReceived), 0, buffer, startIndex + 16, 4); Buffer.BlockCopy(LittleEndian.GetBytes(m_parent.m_dataPointsArchived), 0, buffer, startIndex + 20, 4); Buffer.BlockCopy(LittleEndian.GetBytes(m_parent.m_dataBlockSize), 0, buffer, startIndex + 24, 4); Buffer.BlockCopy(LittleEndian.GetBytes(m_parent.m_dataBlockCount), 0, buffer, startIndex + 28, 4); return(length); }
/// <summary> /// Generates binary image of the <see cref="PacketType101"/> and copies it into the given buffer, for <see cref="BinaryLength"/> bytes. /// </summary> /// <param name="buffer">Buffer used to hold generated binary image of the source object.</param> /// <param name="startIndex">0-based starting index in the <paramref name="buffer"/> to start writing.</param> /// <returns>The number of bytes written to the <paramref name="buffer"/>.</returns> /// <exception cref="ArgumentNullException"><paramref name="buffer"/> is null.</exception> /// <exception cref="ArgumentOutOfRangeException"> /// <paramref name="startIndex"/> or <see cref="BinaryLength"/> is less than 0 -or- /// <paramref name="startIndex"/> and <see cref="BinaryLength"/> will exceed <paramref name="buffer"/> length. /// </exception> public override int GenerateBinaryImage(byte[] buffer, int startIndex) { int length = BinaryLength; buffer.ValidateParameters(startIndex, length); Buffer.BlockCopy(LittleEndian.GetBytes(TypeID), 0, buffer, startIndex, 2); Buffer.BlockCopy(LittleEndian.GetBytes(m_data.Count), 0, buffer, startIndex + 2, 4); for (int i = 0; i < m_data.Count; i++) { m_data[i].GenerateBinaryImage(buffer, startIndex + 6 + (i * PacketType101DataPoint.FixedLength)); } return(length); }
/// <summary> /// Generates binary image of the <see cref="QueryPacketBase"/> and copies it into the given buffer, for <see cref="BinaryLength"/> bytes. /// </summary> /// <param name="buffer">Buffer used to hold generated binary image of the source object.</param> /// <param name="startIndex">0-based starting index in the <paramref name="buffer"/> to start writing.</param> /// <returns>The number of bytes written to the <paramref name="buffer"/>.</returns> /// <exception cref="ArgumentNullException"><paramref name="buffer"/> is null.</exception> /// <exception cref="ArgumentOutOfRangeException"> /// <paramref name="startIndex"/> or <see cref="BinaryLength"/> is less than 0 -or- /// <paramref name="startIndex"/> and <see cref="BinaryLength"/> will exceed <paramref name="buffer"/> length. /// </exception> public override int GenerateBinaryImage(byte[] buffer, int startIndex) { int length = BinaryLength; buffer.ValidateParameters(startIndex, length); Buffer.BlockCopy(LittleEndian.GetBytes(TypeID), 0, buffer, startIndex, 2); Buffer.BlockCopy(LittleEndian.GetBytes(m_requestIDs.Count), 0, buffer, startIndex + 2, 4); for (int i = 0; i < m_requestIDs.Count; i++) { Buffer.BlockCopy(LittleEndian.GetBytes(m_requestIDs[i]), 0, buffer, startIndex + 6 + (i * 4), 4); } return(length); }
public virtual void WriteData(Stream target) { byte[] buffer = new byte[8]; Buffer.BlockCopy(Encoding.ASCII.GetBytes(TypeID), 0, buffer, 0, 4); Buffer.BlockCopy(LittleEndian.GetBytes(ChunkSize), 0, buffer, 4, 4); target.Write(buffer, 0, 8); target.Write(Chunk, 0, Chunk.Length); buffer[0] = 0x0; if (ChunkSize % 2 != 0) { target.Write(buffer, 0, 1); } }
public byte[] GetParameters() { using (var ms = new MemoryStream()) { // parameter count ms.Write(LittleEndian.GetBytes(Parameters.Count), 0, 4); // parameters foreach (var paramValue in Parameters) { ms.Write(LittleEndian.GetBytes((float)paramValue), 0, 4); } return(ms.ToByteArray()); } }
/// <summary> /// Writes next COMTRADE record in float32 format. /// </summary> /// <param name="output">Destination stream.</param> /// <param name="schema">Source schema.</param> /// <param name="timestamp">Record timestamp (implicitly castable as <see cref="DateTime"/>).</param> /// <param name="values">Values to write - 16-bit digitals should exist as a word in an individual double value.</param> /// <param name="sample">User incremented sample index.</param> /// <param name="injectFracSecValue">Determines if FRACSEC value should be automatically injected into stream as first digital - defaults to <c>true</c>.</param> /// <param name="fracSecValue">FRACSEC value to inject into output stream - defaults to 0x0000.</param> /// <remarks> /// This function is primarily intended to write COMTRADE float32 data records based on synchrophasor data /// (see Annex H: Schema for Phasor Data 2150 Using the COMTRADE File Standard in IEEE C37.111-2010), /// it may be necessary to manually write records for other COMTRADE needs (e.g., non 16-bit digitals). /// </remarks> public static void WriteNextRecordFloat32(Stream output, Schema schema, Ticks timestamp, double[] values, uint sample, bool injectFracSecValue = true, ushort fracSecValue = 0x0000) { // Make timestamp relative to beginning of file timestamp -= schema.StartTime.Value; uint microseconds = (uint)(timestamp.ToMicroseconds() / schema.TimeFactor); bool isFirstDigital = true; output.Write(LittleEndian.GetBytes(sample), 0, 4); output.Write(LittleEndian.GetBytes(microseconds), 0, 4); for (int i = 0; i < values.Length; i++) { double value = values[i]; if (i < schema.AnalogChannels.Length) { value -= schema.AnalogChannels[i].Adder; value /= schema.AnalogChannels[i].Multiplier; output.Write(LittleEndian.GetBytes((float)value), 0, 4); } else { if (isFirstDigital) { // Handle automatic injection of IEEE C37.118 FRACSEC digital value if requested isFirstDigital = false; if (injectFracSecValue) { output.Write(LittleEndian.GetBytes(fracSecValue), 0, 2); } } output.Write(LittleEndian.GetBytes((ushort)value), 0, 2); } } // Make sure FRACSEC values are injected if (isFirstDigital && injectFracSecValue) { output.Write(LittleEndian.GetBytes(fracSecValue), 0, 2); } }