public void Test_VISIT_STORAGE() { String FILENAME = "testVisiting.xls"; // Remove... if (File.Exists(FILENAME)) { File.Delete(FILENAME); } //Create... CompoundFile ncf = new CompoundFile(); CFStorage l1 = ncf.RootStorage.AddStorage("Storage Level 1"); l1.AddStream("l1ns1"); l1.AddStream("l1ns2"); l1.AddStream("l1ns3"); CFStorage l2 = l1.AddStorage("Storage Level 2"); l2.AddStream("l2ns1"); l2.AddStream("l2ns2"); ncf.Save(FILENAME); ncf.Close(); // Read... CompoundFile cf = new CompoundFile(FILENAME); FileStream output = new FileStream("reportVisit.txt", FileMode.Create); TextWriter sw = new StreamWriter(output); Console.SetOut(sw); Action <CFItem> va = delegate(CFItem target) { sw.WriteLine(target.Name); }; cf.RootStorage.VisitEntries(va, true); cf.Close(); sw.Close(); }
private void SingleWriteReadMatching(int size) { String filename = "INCREMENTAL_SIZE_MULTIPLE_WRITE_AND_READ_CFS.cfs"; if (File.Exists(filename)) { File.Delete(filename); } CompoundFile cf = new CompoundFile(); CFStorage st = cf.RootStorage.AddStorage("MyStorage"); CFStream sm = st.AddStream("MyStream"); byte[] b = Helpers.GetBuffer(size); sm.SetData(b); cf.Save(filename); cf.Close(); CompoundFile cf2 = new CompoundFile(filename); CFStorage st2 = cf2.RootStorage.GetStorage("MyStorage"); CFStream sm2 = st2.GetStream("MyStream"); Assert.IsNotNull(sm2); Assert.IsTrue(sm2.Size == size); Assert.IsTrue(Helpers.CompareBuffer(sm2.GetData(), b)); cf2.Close(); }
public void Test_WRITE_READ_CFS_VERSION_4_STREAM() { String filename = "WRITE_COMMIT_READ_CFS_V4.cfs"; CompoundFile cf = new CompoundFile(CFSVersion.Ver_4, CFSConfiguration.SectorRecycle | CFSConfiguration.EraseFreeSectors); CFStorage st = cf.RootStorage.AddStorage("MyStorage"); CFStream sm = st.AddStream("MyStream"); byte[] b = Helpers.GetBuffer(227); sm.SetData(b); cf.Save(filename); cf.Close(); CompoundFile cf2 = new CompoundFile(filename); CFStorage st2 = cf2.RootStorage.GetStorage("MyStorage"); CFStream sm2 = st2.GetStream("MyStream"); Assert.IsNotNull(sm2); Assert.IsTrue(sm2.Size == b.Length); cf2.Close(); }
/// <summary> /// Returns the complete tree with all the <see cref="CFStorage"/> and <see cref="CFStream"/> children /// </summary> /// <param name="rootStorage"></param> /// <param name="storage"></param> private static void GetStorageChain(CFStorage rootStorage, CFStorage storage) { Logger.WriteToLog("Copying storage to compound file"); void Entries(CFItem item) { if (item.IsStorage) { var newRootStorage = rootStorage.AddStorage(item.Name); GetStorageChain(newRootStorage, item as CFStorage); } else if (item.IsStream) { var childStream = item as CFStream; if (childStream == null) { return; } var stream = rootStorage.AddStream(item.Name); var bytes = childStream.GetData(); stream.SetData(bytes); } } storage.VisitEntries(Entries, false); }
public void Test_WRITE_AND_READ_CFS_VERSION_4() { String filename = "WRITE_AND_READ_CFS_V4.cfs"; CompoundFile cf = new CompoundFile(CFSVersion.Ver_4, CFSConfiguration.EraseFreeSectors | CFSConfiguration.SectorRecycle); CFStorage st = cf.RootStorage.AddStorage("MyStorage"); CFStream sm = st.AddStream("MyStream"); byte[] b = new byte[220]; sm.SetData(b); cf.Save(filename); cf.Close(); CompoundFile cf2 = new CompoundFile(filename); CFStorage st2 = cf2.RootStorage.GetStorage("MyStorage"); CFStream sm2 = st2.GetStream("MyStream"); Assert.IsNotNull(sm2); Assert.IsTrue(sm2.Size == 220); cf2.Close(); }
public void Test_WRITE_AND_READ_CFS() { String filename = "WRITE_AND_READ_CFS.cfs"; CompoundFile cf = new CompoundFile(); CFStorage st = cf.RootStorage.AddStorage("MyStorage"); CFStream sm = st.AddStream("MyStream"); byte[] b = Helpers.GetBuffer(220, 0x0A); sm.SetData(b); cf.Save(filename); cf.Close(); CompoundFile cf2 = new CompoundFile(filename); CFStorage st2 = cf2.RootStorage.GetStorage("MyStorage"); CFStream sm2 = st2.GetStream("MyStream"); cf2.Close(); Assert.IsNotNull(sm2); Assert.IsTrue(sm2.Size == 220); if (File.Exists(filename)) { File.Delete(filename); } }
public void Test_FIX_BUG_GH_14_GH15() { String filename = "MyFile.dat"; String storageName = "MyStorage"; String streamName = "MyStream"; int BUFFER_SIZE = 800 * Mb; int iterationCount = 1; int streamCount = 3; CompoundFile compoundFileInit = new CompoundFile(CFSVersion.Ver_4, CFSConfiguration.Default); compoundFileInit.Save(filename); compoundFileInit.Close(); CompoundFile compoundFile = new CompoundFile(filename, CFSUpdateMode.Update, CFSConfiguration.Default); CFStorage st = compoundFile.RootStorage.AddStorage(storageName); byte b = 0X0A; byte[] buffer = new byte[BUFFER_SIZE]; for (int streamId = 0; streamId < streamCount; ++streamId) { #if NETCOREAPP Array.Fill(buffer, b); #else for (int i = 0; i < buffer.Length; i++) { buffer[i] = b; } #endif CFStream sm = st.AddStream(streamName + streamId); for (int iteration = 0; iteration < iterationCount; ++iteration) { sm.Append(buffer); compoundFile.Commit(); } b++; } compoundFile.Close(); buffer = null; compoundFile = new CompoundFile(filename, CFSUpdateMode.ReadOnly, CFSConfiguration.Default); byte[] testBuffer = new byte[100]; byte t = 0x0A; for (int streamId = 0; streamId < streamCount; ++streamId) { compoundFile.RootStorage.GetStorage(storageName).GetStream(streamName + streamId).Read(testBuffer, BUFFER_SIZE / 2, 100); Assert.IsTrue(testBuffer.All(g => g == t)); compoundFile.RootStorage.GetStorage(storageName).GetStream(streamName + streamId).Read(testBuffer, BUFFER_SIZE - 101, 100); Assert.IsTrue(testBuffer.All(g => g == t)); compoundFile.RootStorage.GetStorage(storageName).GetStream(streamName + streamId).Read(testBuffer, 0, 100); Assert.IsTrue(testBuffer.All(g => g == t)); t++; } compoundFile.Close(); }
/// <summary> /// Creates this object and sets all it's properties /// </summary> internal Message() { CompoundFile = new CompoundFile(); // In the preceding figure, the "__nameid_version1.0" named property mapping storage contains the // three streams used to provide a mapping from property ID to property name // ("__substg1.0_00020102", "__substg1.0_00030102", and "__substg1.0_00040102") and various other // streams that provide a mapping from property names to property IDs. _nameIdStorage = CompoundFile.RootStorage.TryGetStorage(PropertyTags.NameIdStorage) ?? CompoundFile.RootStorage.AddStorage(PropertyTags.NameIdStorage); var entryStream = _nameIdStorage.AddStream(PropertyTags.EntryStream); entryStream.SetData(new byte[0]); var stringStream = _nameIdStorage.AddStream(PropertyTags.StringStream); stringStream.SetData(new byte[0]); var guidStream = _nameIdStorage.AddStream(PropertyTags.GuidStream); guidStream.SetData(new byte[0]); }
/// <summary> /// Creates this object and reads all the <see cref="EntryStreamItem" /> objects from /// the given <paramref name="storage"/> /// </summary> /// <param name="storage">The <see cref="CFStorage"/> that containts the <see cref="PropertyTags.EntryStream"/></param> internal EntryStream(CFStorage storage) { var stream = storage.TryGetStream(PropertyTags.EntryStream) ?? storage.AddStream(PropertyTags.EntryStream); using (var memoryStream = new MemoryStream(stream.GetData())) using (var binaryReader = new BinaryReader(memoryStream)) while (!binaryReader.Eos()) { var entryStreamItem = new EntryStreamItem(binaryReader); Add(entryStreamItem); } }
internal void Write(CFStorage storage, string streamName) { var stream = storage.TryGetStream(streamName) ?? storage.AddStream(streamName); using (var memoryStream = new MemoryStream()) using (var binaryWriter = new BinaryWriter(memoryStream)) { foreach (var entryStreamItem in this) { entryStreamItem.Write(binaryWriter); } stream.SetData(memoryStream.ToArray()); } }
public void Test_FIX_BUG_GH_14() { String filename = "MyFile.dat"; String storageName = "MyStorage"; String streamName = "MyStream"; int BUFFER_SIZE = 800 * Mb; int iterationCount = 3; int streamCount = 3; CompoundFile compoundFileInit = new CompoundFile(CFSVersion.Ver_4, CFSConfiguration.Default); compoundFileInit.Save(filename); compoundFileInit.Close(); CompoundFile compoundFile = new CompoundFile(filename, CFSUpdateMode.Update, CFSConfiguration.Default); CFStorage st = compoundFile.RootStorage.AddStorage(storageName); byte b = 0X0A; for (int streamId = 0; streamId < streamCount; ++streamId) { CFStream sm = st.AddStream(streamName + streamId); for (int iteration = 0; iteration < iterationCount; ++iteration) { sm.Append(Helpers.GetBuffer(BUFFER_SIZE, b)); compoundFile.Commit(); } b++; } compoundFile.Close(); compoundFile = new CompoundFile(filename, CFSUpdateMode.ReadOnly, CFSConfiguration.Default); byte[] testBuffer = new byte[100]; byte t = 0x0A; for (int streamId = 0; streamId < streamCount; ++streamId) { compoundFile.RootStorage.GetStorage(storageName).GetStream(streamName + streamId).Read(testBuffer, BUFFER_SIZE / 2, 100); Assert.IsTrue(testBuffer.All(g => g == t)); compoundFile.RootStorage.GetStorage(storageName).GetStream(streamName + streamId).Read(testBuffer, BUFFER_SIZE - 101, 100); Assert.IsTrue(testBuffer.All(g => g == t)); compoundFile.RootStorage.GetStorage(storageName).GetStream(streamName + streamId).Read(testBuffer, 0, 100); Assert.IsTrue(testBuffer.All(g => g == t)); t++; } compoundFile.Close(); }
private void CopyStorage(CFStorage source, CFStorage dest) { source.VisitEntries(i => { if (i.IsStorage) { CopyStorage((CFStorage)i, dest.AddStorage(i.Name)); } else if (i.IsStream) { var newStream = dest.AddStream(i.Name); var currStream = (CFStream)i; newStream.SetData(currStream.GetData()); } }, false); }
static void CopyCfStreamsExcept(CFStorage src, CFStorage dest, string excludeName) { src.VisitEntries(i => { if (i.Name?.Equals(excludeName, StringComparison.InvariantCultureIgnoreCase) ?? false) { return; } if (i.IsStorage) { dest.AddStorage(i.Name); CopyCfStreamsExcept((CFStorage)i, dest.GetStorage(i.Name), null); } else { dest.AddStream(i.Name); dest.GetStream(i.Name).SetData(((CFStream)i).GetData()); } }, false); }
/// <summary> /// Добавить поток с указанными зашифрованными данными в указанный каталог файла MCDF. /// </summary> /// <param name="dir">Каталог, в который необходимо добавить поток</param> /// <param name="data">Данные в виде массива байт</param> /// <param name="diskKey">Ключ</param> /// <param name="diskTable">Таблица</param> /// <returns></returns> private static CFStream AddStream(CFStorage dir, byte[] data, byte[] diskKey, byte[] diskTable) { // сгенерировать синхропосылку byte[] synchroArr = GenerateSynchro(); byte[] imito; // зашифровать данные и получить от них хеш Mathdll.CryptData(diskKey, diskTable, synchroArr, ref data, out imito); // создать поток с именем, являющимся 16-тиричным представлением массива байт - imito CFStream stream = dir.AddStream(ReadKey.BinToHex(imito)); // создать бефер для объединения данных и синхропосылки byte[] buffer = new byte[data.Length + synchroArr.Length]; Array.Copy(data, 0, buffer, 0, data.Length); Array.Copy(synchroArr, 0, buffer, data.Length, synchroArr.Length); // записать данные в поток stream.SetData(buffer); // return(stream); }
/// <summary> /// Returns the complete tree with all the <see cref="CFStorage"/> and <see cref="CFStream"/> children /// </summary> /// <param name="rootStorage"></param> /// <param name="storage"></param> private static void GetStorageChain(CFStorage rootStorage, CFStorage storage) { foreach (var child in storage.Children) { if (child.IsStorage) { var newRootStorage = rootStorage.AddStorage(child.Name); GetStorageChain(newRootStorage, child as CFStorage); } else if (child.IsStream) { var childStream = child as CFStream; if (childStream == null) { continue; } var stream = rootStorage.AddStream(child.Name); var bytes = childStream.GetData(); stream.SetData(bytes); } } }
public void Test_FIX_BUG_GH_15() { String filename = "MyFile.dat"; String storageName = "MyStorage"; String streamName = "MyStream"; int BUFFER_SIZE = 800 * Mb; int iterationCount = 6; int streamCount = 1; CompoundFile compoundFile = new CompoundFile(CFSVersion.Ver_4, CFSConfiguration.Default); CFStorage st = compoundFile.RootStorage.AddStorage(storageName); for (int streamId = 0; streamId < streamCount; ++streamId) { CFStream sm = st.AddStream(streamName + streamId); for (int iteration = 0; iteration < iterationCount; ++iteration) { byte b = (byte)(0x0A + iteration); sm.Append(Helpers.GetBuffer(BUFFER_SIZE, b)); } } compoundFile.Save(filename); compoundFile.Close(); byte[] readBuffer = new byte[15]; compoundFile = new CompoundFile(filename); byte c = 0x0A; for (int i = 0; i < iterationCount; i++) { compoundFile.RootStorage.GetStorage(storageName).GetStream(streamName + 0.ToString()).Read(readBuffer, ((long)BUFFER_SIZE + ((long)BUFFER_SIZE * i)) - 15, 15); Assert.IsTrue(readBuffer.All(by => by == c)); c++; } compoundFile.Close(); }
/// <summary> /// Copies the given <paramref name="source"/> to the given <paramref name="destination"/> /// </summary> /// <param name="source"></param> /// <param name="destination"></param> public static void Copy(CFStorage source, CFStorage destination) { source.VisitEntries(action => { if (action.IsStorage) { var destionationStorage = destination.AddStorage(action.Name); destionationStorage.CLSID = action.CLSID; destionationStorage.CreationDate = action.CreationDate; destionationStorage.ModifyDate = action.ModifyDate; Copy(action as CFStorage, destionationStorage); } else { var sourceStream = action as CFStream; var destinationStream = destination.AddStream(action.Name); if (sourceStream != null) { destinationStream.SetData(sourceStream.GetData()); } } }, false); }
private void SingleWriteReadMatchingSTREAMED(int size) { MemoryStream ms = new MemoryStream(size); CompoundFile cf = new CompoundFile(); CFStorage st = cf.RootStorage.AddStorage("MyStorage"); CFStream sm = st.AddStream("MyStream"); byte[] b = Helpers.GetBuffer(size); sm.SetData(b); cf.Save(ms); cf.Close(); CompoundFile cf2 = new CompoundFile(ms); CFStorage st2 = cf2.RootStorage.GetStorage("MyStorage"); CFStream sm2 = st2.GetStream("MyStream"); Assert.IsNotNull(sm2); Assert.IsTrue(sm2.Size == size); Assert.IsTrue(Helpers.CompareBuffer(sm2.GetData(), b)); cf2.Close(); }
/// <summary> /// Returns the complete tree with all the <see cref="CFStorage"/> and <see cref="CFStream"/> children /// </summary> /// <param name="rootStorage"></param> /// <param name="storage"></param> private static void GetStorageChain(CFStorage rootStorage, CFStorage storage) { Action <CFItem> entries = item => { if (item.IsStorage) { var newRootStorage = rootStorage.AddStorage(item.Name); GetStorageChain(newRootStorage, item as CFStorage); } else if (item.IsStream) { var childStream = item as CFStream; if (childStream == null) { return; } var stream = rootStorage.AddStream(item.Name); var bytes = childStream.GetData(); stream.SetData(bytes); } }; storage.VisitEntries(entries, false); }
/// <summary> /// Получить ссылку на объект контейнера с заполненными данными /// </summary> /// <param name="mapXml">Карта</param> /// <param name="szv3Xml">Сводная ведомость</param> /// <param name="szv2XmlArray">Описи пакетов</param> /// <param name="szv1XmlArray">Документы СЗВ-1</param> /// <param name="diskKey">Ключ</param> /// <param name="diskTable">Таблица</param> /// <returns></returns> public static CompoundFile MakeContainer(XmlDocument mapXml, XmlDocument szv3Xml, IEnumerable <XmlDocument> szv2XmlArray, IEnumerable <IEnumerable <XmlDocument> > szv1XmlArray, byte[] diskKey, byte[] diskTable) { XmlElement rootMap = mapXml[MapXml.tagTopics]; XmlElement svodRootMap = rootMap[MapXml.tagSvod]; XmlNodeList lists = rootMap.GetElementsByTagName(MapXml.tagTopics); if (lists.Count != szv2XmlArray.Count() || lists.Count != szv1XmlArray.Count()) { return(null); } CompoundFile container = new CompoundFile(CFSVersion.Ver_3, false, false); CFStorage dir4 = container.RootStorage.AddStorage(rootMap.GetAttribute(MapXml.paramID)); for (int i = 0; i < szv2XmlArray.Count(); i++) { XmlElement curList = lists[i] as XmlElement; XmlElement curOpis = curList[MapXml.tagOpis]; CFStorage curDir = dir4.AddStorage(curList.GetAttribute(MapXml.paramID)); XmlDocument szv2Xml = szv2XmlArray.ElementAt(i); CFStream opisStream = AddStream(curDir, szv2Xml, diskKey, diskTable); curOpis[MapXml.tagFilename].InnerText = opisStream.Name; XmlNodeList docs = curList.GetElementsByTagName(MapXml.tagTopic); if (docs.Count != szv1XmlArray.ElementAt(i).Count()) { continue; } for (int j = 0; j < szv1XmlArray.ElementAt(i).Count(); j++) { /*if (i >= 10 && j >= 51) * { * Console.WriteLine("Packet {0}, Doc {1}", i, j); * }*/ XmlDocument szv1Xml = szv1XmlArray.ElementAt(i).ElementAt(j); XmlElement curDoc = docs[j] as XmlElement; CFStream docStream = AddStream(curDir, szv1Xml, diskKey, diskTable); curDoc[MapXml.tagFilename].InnerText = docStream.Name; } } CFStream svod = AddStream(dir4, szv3Xml, diskKey, diskTable); svodRootMap[MapXml.tagFilename].InnerText = svod.Name; CFStream map = container.RootStorage.AddStream("map"); SetDataToStream(map, mapXml.InnerXml, diskKey, diskTable); CFStorage styleDir = container.RootStorage.AddStorage("styles"); CFStream mapStyleStream = styleDir.AddStream("map_style"); CFStream szv1StyleStream = styleDir.AddStream("szv_style"); CFStream szv3StyleStream = styleDir.AddStream("svod_style"); CFStream szv2StyleStream = styleDir.AddStream("szv_opis_style"); SetDataToStream(mapStyleStream, File.ReadAllBytes(MapXml.GetXslUrl()), diskKey, diskTable); SetDataToStream(szv1StyleStream, File.ReadAllBytes(Szv1Xml.GetXslUrl()), diskKey, diskTable); SetDataToStream(szv3StyleStream, File.ReadAllBytes(Szv3Xml.GetXslUrl()), diskKey, diskTable); SetDataToStream(szv2StyleStream, File.ReadAllBytes(Szv2Xml.GetXslUrl()), diskKey, diskTable); return(container); }
public static CFStream GetOrAddStream(this CFStorage storage, string streamName) { if (storage == null) { throw new ArgumentNullException(nameof(storage)); } return(storage.TryGetStream(streamName, out var childStream) ? childStream : storage.AddStream(streamName)); }
/// <summary> /// Writes all <see cref="Property">properties</see> either as a <see cref="CFStream"/> or as a collection in /// a <see cref="PropertyTags.PropertiesStreamName"/> stream to the given <paramref name="storage"/>, this depends /// on the <see cref="PropertyType"/> /// </summary> /// <param name="storage">The <see cref="CFStorage"/></param> /// <param name="binaryWriter">The <see cref="BinaryWriter" /></param> /// <param name="messageSize">Used to calculate the exact size of the <see cref="Message"/></param> /// <returns> /// Total size of the written <see cref="Properties"/> /// </returns> internal long WriteProperties(CFStorage storage, BinaryWriter binaryWriter, long?messageSize = null) { long size = 0; // The data inside the property stream (1) MUST be an array of 16-byte entries. The number of properties, // each represented by one entry, can be determined by first measuring the size of the property stream (1), // then subtracting the size of the header from it, and then dividing the result by the size of one entry. // The structure of each entry, representing one property, depends on whether the property is a fixed length // property or not. foreach (var property in this) { // property tag: A 32-bit value that contains a property type and a property ID. The low-order 16 bits // represent the property type. The high-order 16 bits represent the property ID. binaryWriter.Write(Convert.ToUInt16(property.Type)); // 2 bytes binaryWriter.Write(Convert.ToUInt16(property.Id)); // 2 bytes binaryWriter.Write(Convert.ToUInt32(property.Flags)); // 4 bytes switch (property.Type) { //case PropertyType.PT_ACTIONS: // break; case PropertyType.PT_APPTIME: case PropertyType.PT_SYSTIME: case PropertyType.PT_DOUBLE: case PropertyType.PT_I8: binaryWriter.Write(property.Data); break; case PropertyType.PT_ERROR: case PropertyType.PT_LONG: case PropertyType.PT_FLOAT: binaryWriter.Write(property.Data); binaryWriter.Write(new byte[4]); break; case PropertyType.PT_SHORT: binaryWriter.Write(property.Data); binaryWriter.Write(new byte[6]); break; case PropertyType.PT_BOOLEAN: binaryWriter.Write(property.Data); binaryWriter.Write(new byte[7]); break; //case PropertyType.PT_CURRENCY: // binaryWriter.Write(property.Data); // break; case PropertyType.PT_UNICODE: // Write the length of the property to the propertiesstream binaryWriter.Write(property.Data.Length + 2); binaryWriter.Write(new byte[4]); storage.AddStream(property.Name).SetData(property.Data); size += property.Data.LongLength; break; case PropertyType.PT_STRING8: // Write the length of the property to the propertiesstream binaryWriter.Write(property.Data.Length + 1); binaryWriter.Write(new byte[4]); storage.AddStream(property.Name).SetData(property.Data); size += property.Data.LongLength; break; case PropertyType.PT_CLSID: binaryWriter.Write(property.Data); break; //case PropertyType.PT_SVREID: // break; //case PropertyType.PT_SRESTRICT: // storage.AddStream(property.Name).SetData(property.Data); // break; case PropertyType.PT_BINARY: // Write the length of the property to the propertiesstream binaryWriter.Write(property.Data.Length); binaryWriter.Write(new byte[4]); storage.AddStream(property.Name).SetData(property.Data); size += property.Data.LongLength; break; case PropertyType.PT_MV_SHORT: break; case PropertyType.PT_MV_LONG: break; case PropertyType.PT_MV_FLOAT: break; case PropertyType.PT_MV_DOUBLE: break; case PropertyType.PT_MV_CURRENCY: break; case PropertyType.PT_MV_APPTIME: break; case PropertyType.PT_MV_LONGLONG: break; case PropertyType.PT_MV_UNICODE: // PropertyType.PT_MV_TSTRING break; case PropertyType.PT_MV_STRING8: break; case PropertyType.PT_MV_SYSTIME: break; //case PropertyType.PT_MV_CLSID: // break; case PropertyType.PT_MV_BINARY: break; case PropertyType.PT_UNSPECIFIED: break; case PropertyType.PT_NULL: break; case PropertyType.PT_OBJECT: // TODO: Adding new MSG file break; } } if (messageSize.HasValue) { binaryWriter.Write(Convert.ToUInt16(PropertyTags.PR_MESSAGE_SIZE.Type)); // 2 bytes binaryWriter.Write(Convert.ToUInt16(PropertyTags.PR_MESSAGE_SIZE.Id)); // 2 bytes binaryWriter.Write(Convert.ToUInt32(PropertyFlags.PROPATTR_READABLE | PropertyFlags.PROPATTR_WRITABLE)); // 4 bytes var totalSize = messageSize.Value + size + 8; var bytes = BitConverter.GetBytes(totalSize); binaryWriter.Write(bytes); binaryWriter.Write(new byte[4]); } // Make the properties stream binaryWriter.BaseStream.Position = 0; var propertiesStream = storage.TryGetStream(PropertyTags.PropertiesStreamName) ?? storage.AddStream(PropertyTags.PropertiesStreamName); propertiesStream.SetData(binaryWriter.BaseStream.ToByteArray()); return(size + binaryWriter.BaseStream.Length); }
/// <summary> /// Returns the complete tree with all the <see cref="CFStorage"/> and <see cref="CFStream"/> children /// </summary> /// <param name="rootStorage"></param> /// <param name="storage"></param> private static void GetStorageChain(CFStorage rootStorage, CFStorage storage) { foreach (var child in storage.Children) { if (child.IsStorage) { var newRootStorage = rootStorage.AddStorage(child.Name); GetStorageChain(newRootStorage, child as CFStorage); } else if (child.IsStream) { var childStream = child as CFStream; if (childStream == null) continue; var stream = rootStorage.AddStream(child.Name); var bytes = childStream.GetData(); stream.SetData(bytes); } } }
public void WriteData(CFStorage gameStorage, HashWriter hashWriter = null) { var itemData = gameStorage.AddStream(StorageName); itemData.SetData(GetBytes(hashWriter)); }
private static void WriteStream(CFStorage storage, string streamName, byte[] data, HashWriter hashWriter = null) { storage.AddStream(streamName).SetData(data); hashWriter?.Write(data); }
private void AddStreamToStorage(CFStorage storage, CFStream stream) { CFStream cfStream = storage.AddStream(stream.Name); cfStream.SetData(stream.GetData()); }