/// <summary> /// Appends all bytes in this memory stream to the end of a file regardless its current position. /// If this memeory stream is empty and the file does not exist, an empty file will be created. /// </summary> /// <param name="ms">A <see cref="System.IO.MemoryStream"/>.</param> /// <param name="path">The path of the file to append.</param> public static void AppendAllBytesToFile(this MemoryStream ms, string path) { if (ms.Length != 0) { using (FileStream fs = new FileStream(path, FileMode.Append, FileAccess.Write)) { fs.WriteBytes(ms.ToArray()); } } }
public void write(string FileName) { FileStream FileStream = new FileStream(FileName, FileMode.OpenOrCreate, FileAccess.Write); FileStream.WriteStruct(this.header); if (this.header.revision >= 3) { FileStream.WriteStruct(this.headerExtraRevision3); } FileStream.WriteStructVector(dimensionTable); FileStream.WriteStructVector(xAdjustTable); FileStream.WriteStructVector(yAdjustTable); FileStream.WriteStructVector(advanceTable); FileStream.WriteStructVector(packedShadowCharMap); if (header.revision == 3) { FileStream.WriteStructVector(charmapCompressionTable1); FileStream.WriteStructVector(charmapCompressionTable2); } FileStream.WriteStructVector(packedCharMap); FileStream.WriteStructVector(packedCharPointerTable); FileStream.WriteBytes(charData); }
private void MoveCaches(string cookedPath, string NewCache) { //DebugOutput.PrintLn( "\nMoving cache...\n"); //Fix the GUID using (FileStream newCache = new FileStream(Path.Combine(cookedPath, NewCache), FileMode.Open, FileAccess.Read)) { SaltPropertyReader.Property GUIDProp = properties["TFCFileGuid"]; for (int i = 0; i < 16; i++) { SaltPropertyReader.PropertyValue tempVal = GUIDProp.Value.Array[i]; tempVal.IntValue = newCache.ReadByte(); GUIDProp.Value.Array[i] = tempVal; } } //Move across any existing textures //using (FileStream oldCache = new FileStream(Path.Combine(cookedPath, arcName + ".tfc"), FileMode.Open, FileAccess.Read)) using (FileStream oldCache = new FileStream(FullArcPath, FileMode.Open, FileAccess.Read)) { using (FileStream newCache = new FileStream(Path.Combine(cookedPath, NewCache), FileMode.Append, FileAccess.Write)) { for (int i = 0; i < privateimgList.Count; i++) { ImageInfo img = privateimgList[i]; switch (img.storageType) { case storage.arcCpr: byte[] buff = new byte[img.cprSize]; oldCache.Seek(img.offset, SeekOrigin.Begin); Buffer.BlockCopy(oldCache.ReadBytes(img.cprSize), 0, buff, 0, img.cprSize); img.offset = (int)newCache.Position; newCache.WriteBytes(buff); break; case storage.arcUnc: buff = new byte[img.uncSize]; oldCache.Seek(img.offset, SeekOrigin.Begin); Buffer.BlockCopy(oldCache.ReadBytes(img.cprSize), 0, buff, 0, img.cprSize); img.offset = (int)newCache.Position; newCache.WriteBytes(buff); break; case storage.pccSto: break; case storage.empty: break; default: throw new NotImplementedException("Storage type not supported yet"); } privateimgList[i] = img; } } } }
public void DumpPCC(string path) { listsStream.Seek(0, SeekOrigin.Begin); byte[] stream = listsStream.ToArray(); using (FileStream fs = new FileStream(path, FileMode.Create)) { fs.WriteBytes(stream); } }
private void dumpRawExportToolStripMenuItem_Click(object sender, EventArgs e) { if (CurrList != 2) return; int n = listBox1.SelectedIndex; if (n < 0) return; PCCObject.ExportEntry exp = pcc.Exports[n]; SaveFileDialog d = new SaveFileDialog(); //d.Filter = "*.u;*.upk;*sfm|*.u;*.upk;*sfm"; d.Filter = "Binary File|*.bin"; if (d.ShowDialog() == System.Windows.Forms.DialogResult.OK) { using (FileStream fs = new FileStream(d.FileName, FileMode.Create, FileAccess.Write)) { fs.WriteBytes(exp.Data); } MessageBox.Show("Done."); } }
/// <summary> /// Write current job to fileStream. /// </summary> /// <param name="fs">FileStream to write to.</param> public void WriteJobToFile(FileStream fs) { // KFreon: Write job name //fs.WriteBytes(BitConverter.GetBytes(Name.Length)); fs.WriteValueS32(Name.Length); foreach (char c in Name) fs.WriteByte((byte)c); // KFreon: Write script //fs.WriteBytes(BitConverter.GetBytes(Script.Length)); fs.WriteValueS32(Script.Length); foreach (char c in Script) fs.WriteByte((byte)c); // KFreon: Write job data //fs.WriteBytes(BitConverter.GetBytes(data.Length)); fs.WriteValueS32(data.Length); fs.WriteBytes(data); }
public void Write(string FileName) { var FileStream = new FileStream(FileName, FileMode.OpenOrCreate, FileAccess.Write); FileStream.WriteStruct(this.Header); if (this.Header.Revision >= 3) { FileStream.WriteStruct(this.HeaderExtraRevision3); } FileStream.WriteStructVector(DimensionTable); FileStream.WriteStructVector(XAdjustTable); FileStream.WriteStructVector(YAdjustTable); FileStream.WriteStructVector(AdvanceTable); FileStream.WriteStructVector(PackedShadowCharMap); if (Header.Revision == 3) { FileStream.WriteStructVector(CharmapCompressionTable1); FileStream.WriteStructVector(CharmapCompressionTable2); } FileStream.WriteStructVector(PackedCharMap); FileStream.WriteStructVector(PackedCharPointerTable); FileStream.WriteBytes(CharData); }
/// <summary> /// save ME3PCCObject to file. /// </summary> /// <param name="newFileName">set full path + file name.</param> /// <param name="saveCompress">set true if you want a zlib compressed pcc file.</param> public void saveToFile(string newFileName = null, bool WriteToMemoryStream = false) { //Refresh header and namelist listsStream.Seek(0, SeekOrigin.End); NameOffset = (int)listsStream.Position; NameCount = Names.Count; foreach (string name in Names) { listsStream.WriteValueS32(-(name.Length + 1)); listsStream.WriteString(name + "\0", (uint)(name.Length + 1) * 2, Encoding.Unicode); } listsStream.Seek(0, SeekOrigin.Begin); listsStream.WriteBytes(header); // KFreon: If want to write to memorystream instead of to file, exit here if (WriteToMemoryStream) return; // Heff: try to remove any read-only attribute if we have permission to: File.SetAttributes(newFileName, FileAttributes.Normal); while (true) { int tries = 0; try { using (FileStream fs = new FileStream(newFileName, FileMode.Create, FileAccess.Write)) { byte[] test = listsStream.ToArray(); fs.WriteBytes(test); test = null; } break; } catch (IOException) { System.Threading.Thread.Sleep(50); tries++; if (tries > 100) { throw new IOException("The PCC can't be written to disk because of an IOException"); } } } listsStream.Dispose(); Exports.Clear(); Imports.Clear(); Names.Clear(); Exports = null; Imports = null; Names = null; GC.Collect(); }
/// <summary> /// Step #5 /// /// Save the unpacked file. /// </summary> /// <returns></returns> private bool Step5() { FileStream fStream = null; byte[] overlayData = null; try { // Determine if the file has any overlay data.. var lastSection = this.File.Sections.Last(); var fileSize = lastSection.SizeOfRawData + lastSection.PointerToRawData; if (fileSize < this.File.FileData.Length) { // Overlay exists, copy it.. overlayData = new byte[this.File.FileData.Length - fileSize]; Array.Copy(this.File.FileData, fileSize, overlayData, 0, this.File.FileData.Length - fileSize); } } catch { return false; } try { // Open the unpacked file for writing.. var unpackedPath = this.File.FilePath + ".unpacked.exe"; fStream = new FileStream(unpackedPath, FileMode.Create, FileAccess.ReadWrite); // Write the dos header back to the file.. fStream.WriteBytes(Helpers.GetStructureBytes(this.File.DosHeader)); // Write the dos stub back to the file if it exists.. if (this.File.DosStubSize > 0) fStream.WriteBytes(this.File.DosStubData); // Determine if we should remove the .bind section.. if (!Program.HasArgument("--keepbind")) { // Remove the .bind section from the file.. this.File.Sections.Remove(this.File.GetSection(".bind")); } // Rebuild the NT headers of the file.. var ntHeaders = this.File.NtHeaders; var lastSection = this.File.Sections[this.File.Sections.Count - 1]; if (!Program.HasArgument("--keepbind")) ntHeaders.FileHeader.NumberOfSections--; ntHeaders.OptionalHeader.AddressOfEntryPoint = this.StubHeader.OriginalEntryPoint; ntHeaders.OptionalHeader.SizeOfImage = lastSection.VirtualAddress + lastSection.VirtualSize; // Write the Nt headers to the file.. fStream.WriteBytes(Helpers.GetStructureBytes(ntHeaders)); // Write the sections to the file.. foreach (var s in this.File.Sections) { // Obtain the sections data from the original file.. var sectionData = new byte[s.SizeOfRawData]; Array.Copy(this.File.FileData, this.File.GetFileOffsetFromRva(s.VirtualAddress), sectionData, 0, s.SizeOfRawData); // Write the section header to the file.. fStream.WriteBytes(Helpers.GetStructureBytes(s)); // Write the section data to the file.. var sectionOffset = fStream.Position; fStream.Position = s.PointerToRawData; // Determine if this is the code section.. if (s.SizeOfRawData == this.CodeSection.SizeOfRawData && s.PointerToRawData == this.CodeSection.PointerToRawData) fStream.WriteBytes(this.CodeSectionData ?? sectionData); else fStream.WriteBytes(sectionData); // Reset the file offset.. fStream.Position = sectionOffset; } // Skip to the end of the stream.. fStream.Position = fStream.Length; // Write the overlay back to the file if it exists.. if (overlayData != null) fStream.WriteBytes(overlayData); return true; } catch { return false; } finally { fStream?.Dispose(); } }
/// <summary> /// This method is an alternate way of saving PCCs /// Instead of reconstructing the PCC from the data taken, it instead copies across the existing /// data, appends new exports, updates the export list, changes the namelist location and updates the /// value in the header /// </summary> /// <param name="newFileName">The filename to write to</param> /// public void appendSave(string newFileName) { IEnumerable<ME2ExportEntry> replaceExports; IEnumerable<ME2ExportEntry> appendExports; int lastDataOffset; int max; if (IsAppend) { replaceExports = exports.Where(export => export.DataChanged && export.DataOffset < NameOffset && export.DataSize <= export.OriginalDataSize); appendExports = exports.Where(export => export.DataOffset > NameOffset || (export.DataChanged && export.DataSize > export.OriginalDataSize)); max = exports.Where(exp => exp.DataOffset < NameOffset).Max(e => e.DataOffset); } else { IEnumerable<ME2ExportEntry> changedExports; changedExports = exports.Where(export => export.DataChanged); replaceExports = changedExports.Where(export => export.DataSize <= export.OriginalDataSize); appendExports = changedExports.Except(replaceExports); max = exports.Max(maxExport => maxExport.DataOffset); } ME2ExportEntry lastExport = exports.Find(export => export.DataOffset == max); lastDataOffset = lastExport.DataOffset + lastExport.DataSize; byte[] oldPCC = new byte[lastDataOffset];//Check whether compressed if (IsCompressed) { oldPCC = CompressionHelper.Decompress(FileName).Take(lastDataOffset).ToArray(); IsCompressed = false; } else { using (FileStream oldPccStream = new FileStream(this.FileName, FileMode.Open)) { //Read the original data up to the last export oldPccStream.Read(oldPCC, 0, lastDataOffset); } } //Start writing the new file using (FileStream newPCCStream = new FileStream(newFileName, FileMode.Create)) { newPCCStream.Seek(0, SeekOrigin.Begin); //Write the original file up til the last original export (note that this leaves in all the original exports) newPCCStream.Write(oldPCC, 0, lastDataOffset); //write the in-place export updates foreach (ME2ExportEntry export in replaceExports) { newPCCStream.Seek(export.DataOffset, SeekOrigin.Begin); export.DataSize = export.Data.Length; newPCCStream.WriteBytes(export.Data); } newPCCStream.Seek(lastDataOffset, SeekOrigin.Begin); //Set the new nameoffset and namecounts NameOffset = (int)newPCCStream.Position; NameCount = names.Count; //Then write out the namelist foreach (string name in names) { newPCCStream.WriteValueS32(name.Length + 1); newPCCStream.WriteString(name); newPCCStream.WriteByte(0); newPCCStream.WriteValueS32(-14); } //Write the import list ImportOffset = (int)newPCCStream.Position; ImportCount = imports.Count; foreach (ImportEntry import in imports) { newPCCStream.WriteBytes(import.header); } //append the new data foreach (ME2ExportEntry export in appendExports) { export.DataOffset = (int)newPCCStream.Position; export.DataSize = export.Data.Length; newPCCStream.Write(export.Data, 0, export.Data.Length); } //Write the export list ExportOffset = (int)newPCCStream.Position; ExportCount = exports.Count; foreach (ME2ExportEntry export in exports) { newPCCStream.WriteBytes(export.header); } IsAppend = true; //write the updated header newPCCStream.Seek(0, SeekOrigin.Begin); newPCCStream.WriteBytes(header); } AfterSave(); }