/// <exception cref="System.IO.IOException"/> public static byte[] ReadCompressedByteArray(BinaryReader reader) { int length = @in.ReadInt(); if (length == -1) { return(null); } byte[] buffer = new byte[length]; @in.ReadFully(buffer); // could/should use readFully(buffer,0,length)? GZIPInputStream gzi = new GZIPInputStream(new ByteArrayInputStream(buffer, 0, buffer .Length)); byte[] outbuf = new byte[length]; ByteArrayOutputStream bos = new ByteArrayOutputStream(); int len; while ((len = gzi.Read(outbuf, 0, outbuf.Length)) != -1) { bos.Write(outbuf, 0, len); } byte[] decompressed = bos.ToByteArray(); bos.Close(); gzi.Close(); return(decompressed); }
/// <summary> /// Uncompresses a GZIP file. /// </summary> /// <param name="bytes"> The compressed bytes. </param> /// <returns> The uncompressed bytes. </returns> /// <exception cref="IOException"> if an I/O error occurs. </exception> public static byte[] Gunzip(byte[] bytes) { /* create the streams */ var @is = new GZIPInputStream(new ByteArrayInputStream(bytes)); try { var os = new ByteArrayOutputStream(); try { /* copy data between the streams */ var buf = new byte[4096]; var len = 0; while ((len = @is.read(buf, 0, buf.Length)) != -1) { os.write(buf, 0, len); } } finally { os.close(); } /* return the uncompressed bytes */ return(os.toByteArray()); } finally { @is.close(); } }
public static IList <Tree> ConvertToTrees(byte[] input) { try { IList <Tree> output = new List <Tree>(); ByteArrayInputStream bis = new ByteArrayInputStream(input); GZIPInputStream gis = new GZIPInputStream(bis); ObjectInputStream ois = new ObjectInputStream(gis); int size = ErasureUtils.UncheckedCast <int>(ois.ReadObject()); for (int i = 0; i < size; ++i) { string rawTree = ErasureUtils.UncheckedCast(ois.ReadObject()); Tree tree = Tree.ValueOf(rawTree, trf); tree.SetSpans(); output.Add(tree); } ois.Close(); gis.Close(); bis.Close(); return(output); } catch (IOException e) { throw new RuntimeIOException(e); } catch (TypeLoadException e) { throw new Exception(e); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void read(String fileName) throws java.io.IOException public virtual void read(string fileName) { System.IO.FileStream fileInputStream = new System.IO.FileStream(fileName, System.IO.FileMode.Open, System.IO.FileAccess.Read); GZIPInputStream gzipInputStream = new GZIPInputStream(fileInputStream); BufferedInputStream bufferedInputStream = new BufferedInputStream(gzipInputStream); StateInputStream stream = new StateInputStream(bufferedInputStream); if (log.InfoEnabled) { Console.WriteLine(string.Format("Reading state from file '{0}'", fileName)); } try { read(stream); if (stream.read() >= 0) { Console.WriteLine(string.Format("State file '{0}' containing too much data", fileName)); } } finally { stream.close(); } //if (log.DebugEnabled) { Console.WriteLine(string.Format("Done reading state from file '{0}'", fileName)); } }
protected AbstractModelReader(Jfile f) { string filename = f.Name; InputStream input; // handle the zipped/not zipped distinction if (filename.EndsWith(".gz", StringComparison.Ordinal)) { input = new GZIPInputStream(new FileInputStream(f)); filename = filename.Substring(0, filename.Length - 3); } else { input = new FileInputStream(f); } // handle the different formats if (filename.EndsWith(".bin", StringComparison.Ordinal)) { dataReader = new BinaryFileDataReader(input); } else // filename ends with ".txt" { dataReader = new PlainTextFileDataReader(input); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public CharReadable apply(final java.io.File file) throws java.io.IOException //JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected: public override CharReadable Apply(File file) { Magic magic = Magic.Of(file); if (magic == Magic.Zip) { // ZIP file ZipFile zipFile = new ZipFile(file); ZipEntry entry = GetSingleSuitableEntry(zipFile); return(wrap(new InputStreamReaderAnonymousInnerClass2(this, zipFile.getInputStream(entry), Charset, file) , file.length())); } else if (magic == Magic.Gzip) { // GZIP file. GZIP isn't an archive like ZIP, so this is purely data that is compressed. // Although a very common way of compressing with GZIP is to use TAR which can combine many // files into one blob, which is then compressed. If that's the case then // the data will look like garbage and the reader will fail for whatever it will be used for. // TODO add tar support GZIPInputStream zipStream = new GZIPInputStream(new FileStream(file, FileMode.Open, FileAccess.Read)); return(wrap(new InputStreamReaderAnonymousInnerClass3(this, zipStream, Charset, file) , file.length())); } else { Stream @in = new FileStream(file, FileMode.Open, FileAccess.Read); Charset usedCharset = this.Charset; if (magic.ImpliesEncoding()) { // Read (and skip) the magic (BOM in this case) from the file we're returning out @in.skip(magic.Length()); usedCharset = magic.Encoding(); } return(wrap(new InputStreamReaderAnonymousInnerClass4(this, @in, usedCharset, file) , file.length())); } }
public virtual int sceGzipDecompress(TPointer outBufferAddr, int outBufferLength, TPointer inBufferAddr, TPointer32 crc32Addr) { if (log.TraceEnabled) { log.trace(string.Format("sceGzipDecompress: {0}", Utilities.getMemoryDump(inBufferAddr.Address, 16))); } int result; CRC32 crc32 = new CRC32(); sbyte[] buffer = new sbyte[4096]; try { // Using a GZIPInputStream instead of an Inflater because the GZIPInputStream // is skipping the GZIP header and this should be done manually with an Inflater. GZIPInputStream @is = new GZIPInputStream(new MemoryInputStream(inBufferAddr.Address)); IMemoryWriter memoryWriter = MemoryWriter.getMemoryWriter(outBufferAddr.Address, outBufferLength, 1); int decompressedLength = 0; while (decompressedLength < outBufferLength) { int Length = @is.read(buffer); if (Length < 0) { // End of GZIP stream break; } if (decompressedLength + Length > outBufferLength) { Console.WriteLine(string.Format("sceGzipDecompress : decompress buffer too small inBuffer={0}, outLength={1:D}", inBufferAddr, outBufferLength)); @is.close(); return(SceKernelErrors.ERROR_INVALID_SIZE); } crc32.update(buffer, 0, Length); for (int i = 0; i < Length; i++) { memoryWriter.writeNext(buffer[i] & 0xFF); } decompressedLength += Length; } @is.close(); memoryWriter.flush(); result = decompressedLength; } catch (IOException e) { Console.WriteLine("sceGzipDecompress", e); return(SceKernelErrors.ERROR_INVALID_FORMAT); } crc32Addr.setValue((int)crc32.Value); return(result); }
/// <exception cref="System.IO.IOException"></exception> internal InputStream OpenInputStream(HttpURLConnection conn) { InputStream input = conn.GetInputStream(); if (HttpSupport.ENCODING_GZIP.Equals(conn.GetHeaderField(HttpSupport.HDR_CONTENT_ENCODING ))) { input = new GZIPInputStream(input); } return(input); }
private InputStream GetStream(DownloadedContent downloadedContent, List <NameValuePair> headers) { InputStream stream = downloadedContent_.InputStream; if (stream == null) { return(null); } if (downloadedContent.IsEmpty()) { return(stream); } String encoding = GetHeader(headers, "content-encoding"); if (encoding != null) { if (StringUtils.contains(encoding, "gzip")) { stream = new GZIPInputStream(stream); } else if (StringUtils.contains(encoding, "deflate")) { bool zlibHeader = false; if (stream.MarkSupported) { // should be always the case as the content is in a byte[] or in a file stream.Mark(2); byte[] buffer = new byte[2]; stream.Read(buffer, 0, 2); zlibHeader = (((buffer[0] & 0xff) << 8) | (buffer[1] & 0xff)) == 0x789c; stream.Reset(); } if (zlibHeader) { stream = new InflaterInputStream(stream); } else { stream = new InflaterInputStream(stream, new Inflater(true)); } } } return(stream); }
public CertificatePinning() { try { byte[] keyStoreBytes = Base64.Decode("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", 0); KeyStore keyStore = KeyStore.GetInstance("BKS"); System.IO.MemoryStream ms = new System.IO.MemoryStream(keyStoreBytes); GZIPInputStream keyStoreInputStream = new GZIPInputStream(ms); //var readbytes = keyStoreInputStream.ToArray<byte>(); List <byte> values = new List <byte>(); bool notdone = true; while (notdone) { var input = keyStoreInputStream.Read(); if (input < 0 || input > 255) { break; } values.Add((byte)input); } try { keyStore.Load(new System.IO.MemoryStream(values.ToArray()), null); } finally { keyStoreInputStream.Close(); } TRUST_STORE = keyStore; String algorithm = TrustManagerFactory.DefaultAlgorithm; TrustManagerFactory trustManagerFactory = TrustManagerFactory.GetInstance(algorithm); trustManagerFactory.Init(keyStore); SSLContext context = SSLContext.GetInstance("TLS"); context.Init(null, trustManagerFactory.GetTrustManagers(), null); SSL_CONTEXT = context; } catch (Exception e) { } }
public FilterInputStreamAnonymousInnerClassHelper(GZIPInputStream outerInstance, InputStream @in) : base(@in) { this.OuterInstance = outerInstance; }
public virtual sbyte[] DecryptAndUncompressPRX(sbyte[] buf, int size) { int compAttribute = readUnaligned16(buf, 0x6); int pspSize = readUnaligned32(buf, 0x2C); int elfSize = readUnaligned32(buf, 0x28); int decryptMode = read8(buf, 0x7C); sbyte[] resultBuffer = new sbyte[size]; Array.Copy(buf, 0, resultBuffer, 0, size); int type; switch (decryptMode) { case DECRYPT_MODE_VSH_MODULE: case DECRYPT_MODE_USER_MODULE: int result = memlmdModule.hleMemlmd_6192F715(resultBuffer, size); //if (log.DebugEnabled) { Console.WriteLine(string.Format("DecryptPRX: memlmd_6192F715 returning 0x{0:X}: {1}", result, Utilities.getMemoryDump(resultBuffer, 0, 0x80 + 0xD0))); } type = 9; break; case DECRYPT_MODE_UMD_GAME_EXEC: type = 9; break; case DECRYPT_MODE_GAMESHARING_EXEC: type = 2; break; case DECRYPT_MODE_MS_UPDATER: type = 8; break; case DECRYPT_MODE_DEMO_EXEC: case DECRYPT_MODE_APP_MODULE: type = 4; break; case DECRYPT_MODE_POPS_EXEC: type = 5; break; default: Console.WriteLine(string.Format("DecryptAndUncompressPRX unknown decryptMode={0:D}", decryptMode)); type = 2; break; } int resultSize = DecryptPRX(resultBuffer, size, type, null, null); if (resultSize < 0) { return(null); } if ((compAttribute & SCE_EXEC_FILE_COMPRESSED) != 0) { if ((compAttribute & 0xF00) == 0) { // GZIP compressed try { GZIPInputStream @in = new GZIPInputStream(new System.IO.MemoryStream(resultBuffer, 0, pspSize)); sbyte[] elfBuffer = new sbyte[elfSize]; int elfOffset = 0; while (elfOffset < elfSize) { int Length = @in.read(elfBuffer, elfOffset, elfSize - elfOffset); if (Length <= 0) { break; } elfOffset += Length; } @in.close(); // Return the uncompressed ELF file resultSize = elfOffset; resultBuffer = elfBuffer; } catch (IOException e) { Console.WriteLine(e); } } else { Console.WriteLine(string.Format("KL4E decompression unimplemented, compAttribute=0x{0:X}", compAttribute)); } } // Truncate the resultBuffer if too long if (resultBuffer.Length > resultSize) { sbyte[] newBuffer = new sbyte[resultSize]; Array.Copy(resultBuffer, 0, newBuffer, 0, resultSize); resultBuffer = newBuffer; } return(resultBuffer); }
/// <exception cref="System.IO.IOException"/> public override Pair <Annotation, InputStream> Read(InputStream @is) { if (compress && !(@is is GZIPInputStream)) { @is = new GZIPInputStream(@is); } BufferedReader reader = new BufferedReader(new InputStreamReader(@is)); Annotation doc = new Annotation(string.Empty); string line; // read the coref graph (new format) IDictionary <int, CorefChain> chains = LoadCorefChains(reader); if (chains != null) { doc.Set(typeof(CorefCoreAnnotations.CorefChainAnnotation), chains); } // read the coref graph (old format) line = reader.ReadLine().Trim(); if (line.Length > 0) { string[] bits = line.Split(" "); if (bits.Length % 4 != 0) { throw new RuntimeIOException("ERROR: Incorrect format for the serialized coref graph: " + line); } IList <Pair <IntTuple, IntTuple> > corefGraph = new List <Pair <IntTuple, IntTuple> >(); for (int i = 0; i < bits.Length; i += 4) { IntTuple src = new IntTuple(2); IntTuple dst = new IntTuple(2); src.Set(0, System.Convert.ToInt32(bits[i])); src.Set(1, System.Convert.ToInt32(bits[i + 1])); dst.Set(0, System.Convert.ToInt32(bits[i + 2])); dst.Set(1, System.Convert.ToInt32(bits[i + 3])); corefGraph.Add(new Pair <IntTuple, IntTuple>(src, dst)); } doc.Set(typeof(CorefCoreAnnotations.CorefGraphAnnotation), corefGraph); } // read individual sentences IList <ICoreMap> sentences = new List <ICoreMap>(); while ((line = reader.ReadLine()) != null) { ICoreMap sentence = new Annotation(string.Empty); // first line is the parse tree. construct it with CoreLabels in Tree nodes Tree tree = new PennTreeReader(new StringReader(line), new LabeledScoredTreeFactory(CoreLabel.Factory())).ReadTree(); sentence.Set(typeof(TreeCoreAnnotations.TreeAnnotation), tree); // read the dependency graphs AnnotationSerializer.IntermediateSemanticGraph intermCollapsedDeps = LoadDependencyGraph(reader); AnnotationSerializer.IntermediateSemanticGraph intermUncollapsedDeps = LoadDependencyGraph(reader); AnnotationSerializer.IntermediateSemanticGraph intermCcDeps = LoadDependencyGraph(reader); // the remaining lines until empty line are tokens IList <CoreLabel> tokens = new List <CoreLabel>(); while ((line = reader.ReadLine()) != null) { if (line.Length == 0) { break; } CoreLabel token = LoadToken(line, haveExplicitAntecedent); tokens.Add(token); } sentence.Set(typeof(CoreAnnotations.TokensAnnotation), tokens); // convert the intermediate graph to an actual SemanticGraph SemanticGraph collapsedDeps = intermCollapsedDeps.ConvertIntermediateGraph(tokens); sentence.Set(typeof(SemanticGraphCoreAnnotations.CollapsedDependenciesAnnotation), collapsedDeps); SemanticGraph uncollapsedDeps = intermUncollapsedDeps.ConvertIntermediateGraph(tokens); sentence.Set(typeof(SemanticGraphCoreAnnotations.BasicDependenciesAnnotation), uncollapsedDeps); SemanticGraph ccDeps = intermCcDeps.ConvertIntermediateGraph(tokens); sentence.Set(typeof(SemanticGraphCoreAnnotations.CollapsedCCProcessedDependenciesAnnotation), ccDeps); sentences.Add(sentence); } doc.Set(typeof(CoreAnnotations.SentencesAnnotation), sentences); return(Pair.MakePair(doc, @is)); }
public InputStreamReaderAnonymousInnerClass3(FromFile outerInstance, GZIPInputStream zipStream, Charset charset, File file) : base(zipStream, charset) { this.outerInstance = outerInstance; this._file = file; }
private InputStream GetStream(DownloadedContent downloadedContent, List<NameValuePair> headers) { InputStream stream = downloadedContent_.InputStream; if (stream == null) { return null; } if (downloadedContent.IsEmpty()) { return stream; } String encoding = GetHeader(headers, "content-encoding"); if (encoding != null) { if (StringUtils.contains(encoding, "gzip")) { stream = new GZIPInputStream(stream); } else if (StringUtils.contains(encoding, "deflate")) { bool zlibHeader = false; if (stream.MarkSupported) { // should be always the case as the content is in a byte[] or in a file stream.Mark(2); byte[] buffer = new byte[2]; stream.Read(buffer, 0, 2); zlibHeader = (((buffer[0] & 0xff) << 8) | (buffer[1] & 0xff)) == 0x789c; stream.Reset(); } if (zlibHeader) { stream = new InflaterInputStream(stream); } else { stream = new InflaterInputStream(stream, new Inflater(true)); } } } return stream; }