/// <summary>
///
/// </summary>
/// <param name="a_stream"></param>
/// <returns></returns>
/// <remarks>Use this function only for VNC Version 3.7 or later.</remarks>
public static HashSet <VncEnum.SecurityType> ReadSecurityTypes(Stream a_stream)
{
// Read number-of-security-types
byte[] buffer = new byte[1];
a_stream.ReadAll(buffer, 0, buffer.Length);
int numberOfSecurityTypes = buffer[0];
if (numberOfSecurityTypes == 0)
{
string str = readReasonString(a_stream);
throw new SecurityException($"Number-of-security-types is zero. {str}");
}
// Read security-types
byte[] securityTypesBuffer = new byte[numberOfSecurityTypes];
a_stream.ReadAll(securityTypesBuffer, 0, numberOfSecurityTypes);
// Create return value
var securityTypes = new HashSet <VncEnum.SecurityType>();
for (int i = 0; i < numberOfSecurityTypes; ++i)
{
securityTypes.Add((VncEnum.SecurityType)securityTypesBuffer[i]);
}
return(securityTypes);
}
private static string readReasonString(Stream a_stream)
{
byte[] reasonLength = new byte[4];
a_stream.ReadAll(reasonLength, 0, reasonLength.Length);
UInt32 len = BigEndianBitConverter.ToUInt32(reasonLength, 0);
byte[] reasonString = new byte[len];
a_stream.ReadAll(reasonString, 0, (int)len);
string str = Encoding.ASCII.GetString(reasonString);
return(str);
}
public void TrieConstructorTest()
{
Trie <TrieElement> trie = new Trie <TrieElement>();
Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("VLUnitTests.Resources.TrieTest.txt");
string text = stream.ReadAll(); // read all data from testing file
// add "references" that will be searched
trie.Add("id.aliquam.lorem");
trie.Add("a.b.c.d");
trie.Add("x.y");
trie.Add("eeee.eeee");
// complete building the trie
trie.CreatePredecessorsAndShortcuts();
TrieElement e = trie.Root;
List <string> foundWords = new List <string>();
// create list of expeced results
List <string> expectedWords = new List <string>();
expectedWords.Add("id.aliquam.lorem");
expectedWords.Add("id.aliquam.lorem");
expectedWords.Add("eeee.eeee");
expectedWords.Add("id.aliquam.lorem");
expectedWords.Add("eeee.eeee");
expectedWords.Add("eeee.eeee");
expectedWords.Add("eeee.eeee");
expectedWords.Add("a.b.c.d");
expectedWords.Add("a.b.c.d");
expectedWords.Add("a.b.c.d");
expectedWords.Add("a.b.c.d");
expectedWords.Add("a.b.c.d");
// run the algorithm
foreach (char c in text)
{
e = trie.Step(e, c);
if (e.IsTerminal)
{
foundWords.Add(e.Word);
}
}
// compare with expected
if (foundWords.Count == expectedWords.Count)
{
bool ok = true;
for (int i = 0; i < foundWords.Count; i++)
{
ok = ok && foundWords[i] == expectedWords[i];
}
Assert.IsTrue(ok);
}
else
{
Assert.Fail("Found and expected words count don't match.");
}
}
// Struct
public static T ReadStruct <T>(this Stream s)
{
byte[] bytes = new byte[BinaryUtils.StructSize <T>()];
s.ReadAll(bytes, 0, bytes.Length);
return(BinaryUtils.StructFromBytes <T>(bytes));
}
private void CalculatePdbChecksumAndId(Stream pdbStream, out byte [] pdbChecksum, out byte [] pdbId)
{
// Get the offset of the PDB heap (this requires parsing several headers
// so it's easier to use the ImageReader directly for this)
Image image = ImageReader.ReadPortablePdb(new Disposable <Stream> (pdbStream, false), "test.pdb", out uint pdbHeapOffset);
pdbId = new byte [20];
Array.Copy(image.PdbHeap.data, 0, pdbId, 0, 20);
pdbStream.Seek(0, SeekOrigin.Begin);
byte [] rawBytes = pdbStream.ReadAll();
var bytes = new byte [rawBytes.Length];
Array.Copy(rawBytes, 0, bytes, 0, pdbHeapOffset);
// Zero out the PDB ID (20 bytes)
for (int i = 0; i < 20; bytes [i + pdbHeapOffset] = 0, i++)
{
;
}
Array.Copy(rawBytes, pdbHeapOffset + 20, bytes, pdbHeapOffset + 20, rawBytes.Length - pdbHeapOffset - 20);
var sha256 = SHA256.Create();
pdbChecksum = sha256.ComputeHash(bytes);
}
public static byte[] ReadDataBlocks(Stream stream, bool discard)
{
byte[] buffer2;
MemoryStream stream2 = discard ? null : new MemoryStream();
using (stream2)
{
while (true)
{
int count = stream.ReadByte();
if (count <= 0)
{
buffer2 = stream2?.ToArray();
break;
}
byte[] buffer = new byte[count];
stream.ReadAll(buffer, 0, count);
if (stream2 != null)
{
stream2.Write(buffer, 0, count);
}
}
}
return(buffer2);
}
public static byte[] ReadDataBlocks(Stream stream, bool discard)
{
MemoryStream ms = discard ? null : new MemoryStream();
using (ms)
{
int len;
while ((len = stream.ReadByte()) > 0)
{
byte[] bytes = new byte[len];
stream.ReadAll(bytes, 0, len);
if (ms != null)
{
ms.Write(bytes, 0, len);
}
}
if (ms != null)
{
return(ms.ToArray());
}
return(null);
}
}
private void PlaySound(Stream sound)
{
DirectSound ds = new DirectSound();
ds.SetCooperativeLevel(this.Handle, CooperativeLevel.Priority);
WaveFormat format = WaveFormat.CreateCustomFormat(
WaveFormatEncoding.Pcm,
44100,
2,
4 * 44100,
4,
16
);
SoundBufferDescription primaryDesc = new SoundBufferDescription();
primaryDesc.Format = format;
primaryDesc.Flags = BufferFlags.GlobalFocus;
primaryDesc.BufferBytes = 8 * 4 * 44100;
PrimarySoundBuffer pBuffer = new PrimarySoundBuffer(ds, primaryDesc);
SoundBufferDescription secondDesc = new SoundBufferDescription();
secondDesc.Format = format;
secondDesc.Flags = BufferFlags.GlobalFocus | BufferFlags.ControlPositionNotify | BufferFlags.GetCurrentPosition2;
secondDesc.BufferBytes = 8 * 4 * 44100;
SecondarySoundBuffer secondBuffer = new SecondarySoundBuffer(ds, secondDesc);
secondBuffer.Write(sound.ReadAll(), 0, LockFlags.None);
secondBuffer.Play(0, PlayFlags.None);
}
void ProcessAsyncResponse(IAsyncResult asyncRes)
{
lock (Lock)
{
var webRequest = asyncRes.AsyncState as HttpWebRequest;
string status;
try
{
using (var response = webRequest.EndGetResponse(asyncRes))
using (Stream stream = response.GetResponseStream())
status = stream.ReadAll();
}
catch (WebException ex)
{
Console.WriteLine("Web Exception: " + ex);
return;
}
try
{
ProcessResponse(status);
}
catch (Exception ex)
{
Console.WriteLine("Processing Exception: " + ex);
return;
}
}
}
internal static byte[] ReadKeyfile(Stream stream)
{
var bytes = stream.ReadAll();
// If the file parses as XML and has the valid structure, then it's an XML keyfile.
if (ReadXmlKeyfile(bytes) is {} xmlKeyfile)
{
return(xmlKeyfile);
}
// Legacy binary precomputed hash key file
if (bytes.Length == 32)
{
return(bytes);
}
// Legacy hexadecimal precomputed hash key file
if (bytes.Length == 64)
{
var text = bytes.ToUtf8();
if (text.IsHex())
{
return(text.DecodeHex());
}
}
// Otherwise it's a generic binary key file which needs to be hashed
return(Crypto.Sha256(bytes));
}
public T Deserialize(Stream source)
{
var all = source.ReadAll();
Array.Reverse(all);
return(inner.deserialize(all));
}
void ProcessInventory(IAsyncResult res)
{
var webRequest = res.AsyncState as HttpWebRequest;
string status;
try
{
using (var response = webRequest.EndGetResponse(res))
using (Stream stream = response.GetResponseStream())
status = stream.ReadAll();
}
catch (WebException ex)
{
Console.WriteLine("Web Exception: " + ex);
return;
}
var data = new JsonReader().Read(status) as IDictionary <string, object>;
var success = data["success"] as bool?;
if (success.HasValue && success.Value == false)
{
return;
}
Inventory = new Inventory();
Inventory.TryParse(data);
var @event = new TradeEvent();
@event.type = ETradeEventType.InventoryLoaded;
Events.Enqueue(@event);
}
static public void CreateCompression15File(Stream InputStream, Stream OutputStream, int FallbackCompression = 15)
{
var TempFile = Path.GetTempFileName();
File.WriteAllBytes(TempFile, InputStream.ReadAll());
CreateCompression15File(TempFile, OutputStream, FallbackCompression);
}
/// <inheritdoc />
public void ReadMessage(ITransport transport, CancellationToken cancellationToken = default)
{
if (transport == null)
{
throw new ArgumentNullException(nameof(transport));
}
cancellationToken.ThrowIfCancellationRequested();
// Did we just learn that the server supports fences?
if (!_state.ServerSupportsFences)
{
_logger.LogDebug("Server supports the fences extension.");
// Mark the encoding and message type as used
_state.EnsureEncodingTypeIsMarkedAsUsed <IPseudoEncodingType>(null, (int)WellKnownEncodingType.Fence);
_state.EnsureMessageTypeIsMarkedAsUsed <IOutgoingMessageType>(null, (byte)WellKnownOutgoingMessageType.ClientFence);
_state.ServerSupportsFences = true;
}
Stream transportStream = transport.Stream;
// Read 8 header bytes (first 3 bytes are padding)
Span <byte> header = stackalloc byte[8];
transportStream.ReadAll(header, cancellationToken);
var flags = (FenceFlags)BinaryPrimitives.ReadUInt32BigEndian(header[3..]);
/// <summary>
/// Reads the content.
/// </summary>
/// <param name="stream">The stream.</param>
/// <returns></returns>
public byte[] ReadContent(Stream stream)
{
int? contentLength = null;
IList <string> literalContentLength;
if (Headers.TryGetValue("Content-Length", out literalContentLength))
{
int fContentLength;
if (int.TryParse(literalContentLength.First(), out fContentLength))
{
contentLength = fContentLength;
}
}
if (!contentLength.HasValue)
{
using (var memoryStream = new MemoryStream())
{
stream.CopyTo(memoryStream);
return(memoryStream.ToArray());
}
}
var contentBytes = new byte[contentLength.Value];
stream.ReadAll(contentBytes, 0, contentBytes.Length);
return(contentBytes);
}
public static VncEnum.Version ReadProtocolVersion(Stream a_stream, VncEnum.Version a_forceVersion)
{
byte[] buffer = new byte[12];
a_stream.ReadAll(buffer, 0, buffer.Length);
if (buffer.SequenceEqual(Encoding.ASCII.GetBytes("RFB 003.003\n")) ||
buffer.SequenceEqual(Encoding.ASCII.GetBytes("RFB 003.005\n")))
{
return(VncEnum.Version.Version33);
}
else if (buffer.SequenceEqual(Encoding.ASCII.GetBytes("RFB 003.007\n")))
{
return(VncEnum.Version.Version37);
}
else if (buffer.SequenceEqual(Encoding.ASCII.GetBytes("RFB 003.008\n")))
{
return(VncEnum.Version.Version38);
}
// In rare cases, it may be a strange response, so if a_forceVersion is not Invalid, it is permitted if the beginning matches.
if (a_forceVersion != VncEnum.Version.None)
{
if (Encoding.ASCII.GetString(buffer).Contains("RFB 003"))
{
return(a_forceVersion);
}
}
throw new InvalidDataException($"Unknown version. Length = {buffer.Length} Text = [{Encoding.ASCII.GetString(buffer)}]");
}
public static string ReadString(Stream stream, int length)
{
var bytes = new byte[length];
stream.ReadAll(bytes, 0, length);
return(Encoding.ASCII.GetString(bytes));
}
public byte[] ReadBytes()
{
using (Stream stream = Open())
{
return(stream.ReadAll());
}
}
public static byte[] ReadVncChallange(Stream a_stream)
{
byte[] buffer = new byte[16];
a_stream.ReadAll(buffer, 0, buffer.Length);
return(buffer);
}
/// <summary>
/// Reads the specified stream.
/// </summary>
/// <param name="stream">The stream.</param>
/// <returns>The file</returns>
public override IGenericFile Read(Stream stream)
{
if (stream is null)
{
return(new GenericFile("", "", ""));
}
try
{
var Content = stream.ReadAll();
var doc = new HtmlAgilityPack.HtmlDocument();
doc.LoadHtml(Content);
var Title = doc.DocumentNode.SelectSingleNode("//head//title")?.InnerText ?? string.Empty;
var Meta = new Regex(@"<meta\s*name=[""']description[""']\s*content=[""'](?<Content>[^""']*)[""']\s*/>", RegexOptions.IgnoreCase).Match(Content).Groups["Content"].Value;
Meta += new Regex(@"<meta\s*name=[""']keywords[""']\s*content=[""'](?<Content>[^""']*)[""']\s*/>", RegexOptions.IgnoreCase).Match(Content).Groups["Content"].Value;
doc.DocumentNode.SelectSingleNode("//body")
.Descendants("style")
.ToList()
.ForEach(x => x.Remove());
doc.DocumentNode.SelectSingleNode("//body")
.Descendants("script")
.ToList()
.ForEach(x => x.Remove());
Content = doc.DocumentNode.SelectSingleNode("//body").InnerHtml;
Content = StripHTML(Content);
Content = Content.Replace("&", "&").Replace("’", "'");
var RemoveSpaces = new Regex(@"\s+", RegexOptions.None);
return(new GenericFile(RemoveSpaces.Replace(Content, " ").Trim(), Title, Meta));
}
catch
{
return(new GenericFile("", "", ""));
}
}
private void Read(Stream stream, IEnumerable <GifExtension> controlExtensions, bool metadataOnly)
{
//Note: at this point, the label (0x01) has already been read
var bytes = new byte[13];
stream.ReadAll(bytes, 0, bytes.Length);
BlockSize = bytes[0];
if (BlockSize != 12)
{
throw GifHelpers.InvalidBlockSizeException("Plain Text Extension", 12, BlockSize);
}
Left = BitConverter.ToUInt16(bytes, 1);
Top = BitConverter.ToUInt16(bytes, 3);
Width = BitConverter.ToUInt16(bytes, 5);
Height = BitConverter.ToUInt16(bytes, 7);
CellWidth = bytes[9];
CellHeight = bytes[10];
ForegroundColorIndex = bytes[11];
BackgroundColorIndex = bytes[12];
var dataBytes = GifHelpers.ReadDataBlocks(stream, metadataOnly);
Text = Encoding.ASCII.GetString(dataBytes);
Extensions = controlExtensions.ToList().AsReadOnly();
}
internal ExperimentalPacket(
PacketTag tag,
Stream bcpgIn)
{
this.tag = tag;
this.contents = bcpgIn.ReadAll();
}
/// <summary>
/// Adds a Base64 signature to a feed or catalog stream.
/// </summary>
/// <param name="stream">The feed or catalog to sign.</param>
/// <param name="secretKey">The secret key to use for signing the file.</param>
/// <param name="passphrase">The passphrase to use to unlock the key.</param>
/// <param name="openPgp">The OpenPGP-compatible system used to create signatures.</param>
/// <exception cref="IOException">The file could not be read or written.</exception>
/// <exception cref="UnauthorizedAccessException">Read or write access to the file is not permitted.</exception>
/// <exception cref="KeyNotFoundException">The specified <paramref name="secretKey"/> could not be found on the system.</exception>
/// <exception cref="WrongPassphraseException"><paramref name="passphrase"/> was incorrect.</exception>
/// <remarks>
/// The file is not parsed before signing; invalid XML files are signed as well.
/// The existing file must end with a line break.
/// Old signatures are not removed.
/// </remarks>
public static void SignFeed(Stream stream, OpenPgpSecretKey secretKey, string?passphrase, IOpenPgp openPgp)
{
#region Sanity checks
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
if (secretKey == null)
{
throw new ArgumentNullException(nameof(secretKey));
}
if (openPgp == null)
{
throw new ArgumentNullException(nameof(openPgp));
}
#endregion
// Calculate the signature in-memory
var signature = openPgp.Sign(stream.ReadAll(), secretKey, passphrase);
// Add the signature to the end of the file
var writer = new StreamWriter(stream, EncodingUtils.Utf8)
{
NewLine = "\n"
};
writer.Write(StoreFeedUtils.SignatureBlockStart);
writer.WriteLine(Convert.ToBase64String(signature));
writer.Write(StoreFeedUtils.SignatureBlockEnd);
writer.Flush();
}
//todo 修改为不抛出异常，失败时返回null
public T Deserialize <T>(Stream stream)
{
JavaScriptSerializer serializer = new JavaScriptSerializer();
T obj = serializer.Deserialize <T>(stream.ReadAll().ToString());
return(obj);
}
static public String ReadAllContentsAsString(this Stream Stream, Encoding Encoding = null, bool FromStart = true)
{
if (Encoding == null)
{
Encoding = Encoding.UTF8;
}
return(Encoding.GetString(Stream.ReadAll(FromStart)));
}
public override int Read(byte[] buffer, int offset, int count)
{
if (!CanRead)
{
throw new InvalidOperationException();
}
return(_pipeStream.ReadAll(buffer, offset, count));
}
/// <summary>
/// Gets the content.
/// </summary>
/// <param name="stream">The stream.</param>
/// <returns>The content in the stream.</returns>
private static string GetContent(Stream stream)
{
try
{
return(stream.ReadAll());
}
catch { return(""); }
}
public static object ReadReference(Stream stream)
{
Span <byte> reference = stackalloc byte[(int)stream.Length];
stream.ReadAll(reference);
return(ReadReference(reference));
}
private static List <byte[]> readServerCutText(Stream a_stream)
{
var readDataList = new List <byte[]>();
// Read padding(3) - length(4)
byte[] head = new byte[7];
a_stream.ReadAll(head, 0, head.Length);
readDataList.Add(head);
UInt16 length = BigEndianBitConverter.ToUInt16(head, 3);
// Read text(length)
byte[] textBuffer = new byte[length];
a_stream.ReadAll(textBuffer, 0, textBuffer.Length);
readDataList.Add(textBuffer);
return(readDataList);
}
public static VncServerInitBody ReadServerInit(Stream a_stream)
{
// Read head for name-length
byte[] buffer = new byte[24];
a_stream.ReadAll(buffer, 0, buffer.Length);
int len = (int)BigEndianBitConverter.ToUInt32(buffer, 20);
// Read name-string
byte[] str = new byte[len];
a_stream.ReadAll(str, 0, len);
// Create VncServerInitBody
Array.Resize(ref buffer, 24 + len);
Array.Copy(str, 0, buffer, 24, len);
return(new VncServerInitBody(buffer));
}
public void LoadFromStream(Stream stream)
{
int lengthToFill = (int)(stream.Length - stream.Position);
while (m_buffer.Data.Length < lengthToFill)
m_buffer.Grow();
m_buffer.Position = 0;
m_length = lengthToFill;
stream.ReadAll(m_buffer.Data, 0, lengthToFill);
Reset();
}
private void Read(Stream stream)
{
byte[] bytes = new byte[9];
stream.ReadAll(bytes, 0, bytes.Length);
Left = BitConverter.ToUInt16(bytes, 0);
Top = BitConverter.ToUInt16(bytes, 2);
Width = BitConverter.ToUInt16(bytes, 4);
Height = BitConverter.ToUInt16(bytes, 6);
byte packedFields = bytes[8];
HasLocalColorTable = (packedFields & 0x80) != 0;
Interlace = (packedFields & 0x40) != 0;
IsLocalColorTableSorted = (packedFields & 0x20) != 0;
LocalColorTableSize = 1 << ((packedFields & 0x07) + 1);
}
public static GifColor[] ReadColorTable(Stream stream, int size)
{
int length = 3 * size;
byte[] bytes = new byte[length];
stream.ReadAll(bytes, 0, length);
GifColor[] colorTable = new GifColor[size];
for (int i = 0; i < size; i++)
{
byte r = bytes[3 * i];
byte g = bytes[3 * i + 1];
byte b = bytes[3 * i + 2];
colorTable[i] = new GifColor(r, g, b);
}
return colorTable;
}
public static GifColor[] ReadColorTable(Stream stream, int size)
{
var length = 3*size;
var bytes = new byte[length];
stream.ReadAll(bytes, 0, length);
var colorTable = new GifColor[size];
for (var i = 0; i < size; i++)
{
var r = bytes[3*i];
var g = bytes[3*i + 1];
var b = bytes[3*i + 2];
colorTable[i] = new GifColor(r, g, b);
}
return colorTable;
}
private void Read(Stream stream)
{
// Note: at this point, the label (0xFF) has already been read
byte[] bytes = new byte[12];
stream.ReadAll(bytes, 0, bytes.Length);
BlockSize = bytes[0]; // should always be 11
if (BlockSize != 11)
throw GifHelpers.InvalidBlockSizeException("Application Extension", 11, BlockSize);
ApplicationIdentifier = Encoding.ASCII.GetString(bytes, 1, 8);
byte[] authCode = new byte[3];
Array.Copy(bytes, 9, authCode, 0, 3);
AuthenticationCode = authCode;
Data = GifHelpers.ReadDataBlocks(stream, false);
}
private void Read(Stream stream)
{
// Note: at this point, the label (0xF9) has already been read
byte[] bytes = new byte[6];
stream.ReadAll(bytes, 0, bytes.Length);
BlockSize = bytes[0]; // should always be 4
if (BlockSize != 4)
throw GifHelpers.InvalidBlockSizeException("Graphic Control Extension", 4, BlockSize);
byte packedFields = bytes[1];
DisposalMethod = (packedFields & 0x1C) >> 2;
UserInput = (packedFields & 0x02) != 0;
HasTransparency = (packedFields & 0x01) != 0;
Delay = BitConverter.ToUInt16(bytes, 2) * 10; // milliseconds
TransparencyIndex = bytes[4];
}
public virtual void Load(Stream FileStream)
{
FileStream = new MemoryStream(FileStream.ReadAll());
this.FileStream = FileStream;
this.Header = FileStream.ReadStruct<Elf.HeaderStruct>();
if (this.Header.Magic != Elf.HeaderStruct.MagicEnum.ExpectedValue)
{
throw(new InvalidProgramException("Not an ELF File"));
}
if (this.Header.Machine != Elf.HeaderStruct.MachineEnum.ALLEGREX)
{
throw (new InvalidProgramException("Invalid Elf.Header.Machine"));
}
this.ProgramHeaders = FileStream.ReadStructVectorAt<Elf.ProgramHeader>(Header.ProgramHeaderOffset, Header.ProgramHeaderCount, Header.ProgramHeaderEntrySize);
this.SectionHeaders = FileStream.ReadStructVectorAt<Elf.SectionHeader>(Header.SectionHeaderOffset, Header.SectionHeaderCount, Header.SectionHeaderEntrySize);
this.NamesSectionHeader = this.SectionHeaders[Header.SectionHeaderStringTable];
this.StringTable = FileStream.SliceWithLength(this.NamesSectionHeader.Offset, this.NamesSectionHeader.Size).ReadAll();
this.SectionHeadersByName = new Dictionary<string, Elf.SectionHeader>();
foreach (var SectionHeader in this.SectionHeaders)
{
var SectionHeaderName = GetStringFromStringTable(SectionHeader.Name);
this.SectionHeadersByName[SectionHeaderName] = SectionHeader;
}
Console.WriteLine("ProgramHeaders:{0}", this.ProgramHeaders.Length);
foreach (var ProgramHeader in ProgramHeaders)
{
Console.WriteLine("{0}", ProgramHeader.ToStringDefault());
}
Console.WriteLine("SectionHeaders:{0}", this.SectionHeaders.Length);
foreach (var SectionHeader in SectionHeaders)
{
Console.WriteLine("{0}:{1}", GetStringFromStringTable(SectionHeader.Name), SectionHeader.ToStringDefault());
}
if (NeedsRelocation && this.ProgramHeaders.Length > 1)
{
//throw (new NotImplementedException("Not implemented several ProgramHeaders yet using relocation"));
}
}
public static byte[] ReadDataBlocks(Stream stream, bool discard)
{
MemoryStream ms = discard ? null : new MemoryStream();
using (ms)
{
int len;
while ((len = stream.ReadByte()) > 0)
{
byte[] bytes = new byte[len];
stream.ReadAll(bytes, 0, len);
if (ms != null)
ms.Write(bytes, 0, len);
}
if (ms != null)
return ms.ToArray();
return null;
}
}
private void Read(Stream stream)
{
byte[] bytes = new byte[7];
stream.ReadAll(bytes, 0, bytes.Length);
Width = BitConverter.ToUInt16(bytes, 0);
Height = BitConverter.ToUInt16(bytes, 2);
byte packedFields = bytes[4];
HasGlobalColorTable = (packedFields & 0x80) != 0;
ColorResolution = ((packedFields & 0x70) >> 4) + 1;
IsGlobalColorTableSorted = (packedFields & 0x08) != 0;
GlobalColorTableSize = 1 << ((packedFields & 0x07) + 1);
BackgroundColorIndex = bytes[5];
PixelAspectRatio =
bytes[5] == 0
? 0.0
: (15 + bytes[5]) / 64.0;
}
private void Read(Stream stream, IEnumerable<GifExtension> controlExtensions, bool metadataOnly)
{
// Note: at this point, the label (0x01) has already been read
byte[] bytes = new byte[13];
stream.ReadAll(bytes,0, bytes.Length);
BlockSize = bytes[0];
if (BlockSize != 12)
throw GifHelpers.InvalidBlockSizeException("Plain Text Extension", 12, BlockSize);
Left = BitConverter.ToUInt16(bytes, 1);
Top = BitConverter.ToUInt16(bytes, 3);
Width = BitConverter.ToUInt16(bytes, 5);
Height = BitConverter.ToUInt16(bytes, 7);
CellWidth = bytes[9];
CellHeight = bytes[10];
ForegroundColorIndex = bytes[11];
BackgroundColorIndex = bytes[12];
var dataBytes = GifHelpers.ReadDataBlocks(stream, metadataOnly);
Text = Encoding.ASCII.GetString(dataBytes);
Extensions = controlExtensions.ToList().AsReadOnly();
}
/// <summary>
/// Reads the content.
/// </summary>
/// <param name="stream">The stream.</param>
/// <returns></returns>
public byte[] ReadContent(Stream stream)
{
int? contentLength = null;
IList<string> literalContentLength;
if (Headers.TryGetValue("Content-Length", out literalContentLength))
{
int fContentLength;
if (int.TryParse(literalContentLength.First(), out fContentLength))
contentLength = fContentLength;
}
if (!contentLength.HasValue)
{
using (var memoryStream = new MemoryStream())
{
stream.CopyTo(memoryStream);
return memoryStream.ToArray();
}
}
var contentBytes = new byte[contentLength.Value];
stream.ReadAll(contentBytes, 0, contentBytes.Length);
return contentBytes;
}
public static string ReadString(Stream stream, int length)
{
byte[] bytes = new byte[length];
stream.ReadAll(bytes, 0, length);
return Encoding.ASCII.GetString(bytes);
}
public HleModuleGuest LoadModule(Stream FileStream, Stream MemoryStream, MemoryPartition MemoryPartition, HleModuleManager ModuleManager, String GameTitle, string ModuleName, bool IsMainModule)
{
this.HleModuleGuest = new HleModuleGuest(PspEmulatorContext);
this.ElfLoader = new ElfLoader();
this.ModuleManager = ModuleManager;
var Magic = FileStream.SliceWithLength(0, 4).ReadString(4);
Logger.Info("Magic: '{0}'", Magic);
if (Magic == "~PSP")
{
try
{
var DecryptedData = new EncryptedPrx().Decrypt(FileStream.ReadAll(), true);
File.WriteAllBytes("last_decoded_prx.bin", DecryptedData);
FileStream = new MemoryStream(DecryptedData);
}
catch (Exception Exception)
{
Logger.Error(Exception);
throw (Exception);
}
}
this.ElfLoader.Load(FileStream, ModuleName);
PspEmulatorContext.PspConfig.InfoExeHasRelocation = this.ElfLoader.NeedsRelocation;
if (this.ElfLoader.NeedsRelocation)
{
var DummyPartition = MemoryPartition.Allocate(
0x4000,
Name: "Dummy"
);
BaseAddress = MemoryPartition.ChildPartitions.OrderByDescending(Partition => Partition.Size).First().Low;
Logger.Info("BASE ADDRESS (Try ): 0x{0:X}", BaseAddress);
BaseAddress = MathUtils.NextAligned(BaseAddress, 0x1000);
Logger.Info("BASE ADDRESS (Aligned): 0x{0:X}", BaseAddress);
}
else
{
BaseAddress = 0;
}
PspEmulatorContext.PspConfig.RelocatedBaseAddress = BaseAddress;
PspEmulatorContext.PspConfig.GameTitle = GameTitle;
this.ElfLoader.AllocateAndWrite(MemoryStream, MemoryPartition, BaseAddress);
if (this.ElfLoader.NeedsRelocation)
{
RelocateFromHeaders();
}
if (!ElfLoader.SectionHeadersByName.ContainsKey(".rodata.sceModuleInfo"))
{
throw(new Exception("Can't find segment '.rodata.sceModuleInfo'"));
}
HleModuleGuest.ModuleInfo = ElfLoader.SectionHeaderFileStream(ElfLoader.SectionHeadersByName[".rodata.sceModuleInfo"]).ReadStruct<ElfPsp.ModuleInfo>(); ;
//Console.WriteLine(this.ModuleInfo.ToStringDefault());
HleModuleGuest.InitInfo = new InitInfoStruct()
{
PC = ElfLoader.Header.EntryPoint + BaseAddress,
GP = HleModuleGuest.ModuleInfo.GP + BaseAddress,
};
UpdateModuleImports();
UpdateModuleExports();
ModuleManager.LoadedGuestModules.Add(HleModuleGuest);
return HleModuleGuest;
}
/// <summary>
/// Builds a FormData from the specified input stream,
/// which is assumed to be in x-www-form-urlencoded format.
/// </summary>
/// <param name="stream">the input stream</param>
/// <returns>a populated FormData object</returns>
public static Task<FormData> ParseUrlEncoded(Stream stream) {
var form = new FormData();
string input = stream.ReadAll();
var pairs = input.Split(UrlSplitTokens, StringSplitOptions.RemoveEmptyEntries);
foreach (var pair in pairs) {
var nameValue = pair.Split('=');
form[nameValue[0]] = UrlHelper.Decode(nameValue[1]);
}
return TaskHelper.Completed(form);
}
