public static void ChangePositionViaPointer()
{
byte[] data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 127, 255 };
unsafe
{
fixed (byte* bytePtr = data)
{
using (var stream = new UnmanagedMemoryStream(bytePtr, data.Length, data.Length, FileAccess.ReadWrite))
{
// Make sure the position pointer is where we set it to be
Assert.Equal(expected: (IntPtr)bytePtr, actual: (IntPtr)stream.PositionPointer);
// Make sure that moving earlier than the beginning of the stream throws
Assert.Throws<IOException>(() => {
stream.PositionPointer = stream.PositionPointer - 1;
});
// Make sure that moving later than the length can be done but then
// fails appropriately during reads and writes, and that the stream's
// data is still intact after the fact
stream.PositionPointer = bytePtr + data.Length;
VerifyNothingCanBeReadOrWritten(stream, data);
CheckStreamIntegrity(stream, data);
}
} // fixed
}
}
private static void SelfTest()
{
UnmanagedMemoryStream ms1 = new UnmanagedMemoryStream();
BinaryStreamBase ms = ms1.CreateBinaryStream();
Random rand = new Random();
int seed = rand.Next();
rand = new Random(seed);
byte[] data = new byte[255];
rand.NextBytes(data);
while (ms.Position < 1000000)
{
ms.Write(data, 0, rand.Next(256));
}
byte[] data2 = new byte[255];
rand = new Random(seed);
rand.NextBytes(data2);
ms.Position = 0;
Compare(data, data2, 255);
while (ms.Position < 1000000)
{
int length = rand.Next(256);
ms.ReadAll(data2, 0, length);
Compare(data, data2, length);
}
ms.Dispose();
ms1.Dispose();
}
public static void OneByteStreamRead()
{
using (var manager = new UmsManager(FileAccess.Read, new byte[] { 100 }))
{
UnmanagedMemoryStream stream = manager.Stream;
UmsTests.ReadUmsInvariants(stream);
var position = stream.Position;
Assert.Equal(stream.ReadByte(), 100);
Assert.Equal(stream.Position, position + 1);
position = stream.Position;
Assert.Equal(stream.ReadByte(), -1); // end of stream
Assert.Equal(stream.Position, position);
}
using (HGlobalSafeBuffer buffer = new HGlobalSafeBuffer(1))
using (var stream = new UnmanagedMemoryStream(buffer, 0, 1, FileAccess.ReadWrite))
{
buffer.Write(0, (byte)100);
var position = stream.Position;
Assert.Equal(stream.ReadByte(), 100);
Assert.Equal(stream.Position, position + 1);
Assert.Equal(stream.ReadByte(), -1); // end of stream
Assert.Equal(stream.Position, position + 1);
}
}
internal static void ReadWriteUmsInvariants(UnmanagedMemoryStream stream)
{
UmsInvariants(stream);
Assert.True(stream.CanRead);
Assert.True(stream.CanWrite);
Assert.True(stream.CanSeek);
}
internal static void ReadUmsInvariants(UnmanagedMemoryStream stream)
{
UmsInvariants(stream);
Assert.True(stream.CanRead);
Assert.False(stream.CanWrite);
Assert.True(stream.CanSeek);
Assert.Throws<NotSupportedException>(() => stream.SetLength(1000));
}
public void Test()
{
MemoryPoolTest.TestMemoryLeak();
SelfTest();
UnmanagedMemoryStream ms = new UnmanagedMemoryStream();
BinaryStreamTest.Test(ms);
Assert.IsTrue(true);
ms.Dispose();
MemoryPoolTest.TestMemoryLeak();
}
public static unsafe void PointerCtor()
{
int someInt32 = 42;
int* pInt32 = &someInt32;
byte* pByte = (byte*)pInt32;
using (var stream = new UnmanagedMemoryStream(pByte, 0))
{
Assert.True(stream.CanRead);
Assert.True(stream.CanSeek);
Assert.False(stream.CanWrite);
Assert.False(stream.CanTimeout);
Assert.Equal(0, stream.Length);
Assert.Equal(0, stream.Capacity);
Assert.Equal(0, stream.Position);
Assert.Throws<InvalidOperationException>(() => stream.ReadTimeout);
Assert.Throws<InvalidOperationException>(() => stream.ReadTimeout = 42);
Assert.Throws<InvalidOperationException>(() => stream.WriteTimeout);
Assert.Throws<InvalidOperationException>(() => stream.WriteTimeout = 42);
Assert.True(stream.PositionPointer == pByte);
}
using (var stream = new DerivedUnmanagedMemoryStream())
{
Assert.False(stream.CanRead);
Assert.False(stream.CanSeek);
Assert.False(stream.CanWrite);
Assert.False(stream.CanTimeout);
Assert.Throws<ArgumentOutOfRangeException>(() => stream.Initialize(pByte, -1, 4, FileAccess.Read));
Assert.Throws<ArgumentOutOfRangeException>(() => stream.Initialize(pByte, 1, -4, FileAccess.Read));
Assert.Throws<ArgumentOutOfRangeException>(() => stream.Initialize(pByte, 5, 4, FileAccess.Read));
Assert.Throws<ArgumentOutOfRangeException>(() => stream.Initialize(pByte, 1, 4, (FileAccess)12345));
stream.Initialize(pByte, 1, 4, FileAccess.ReadWrite);
Assert.Throws<InvalidOperationException>(() => stream.Initialize(pByte, 1, 4, FileAccess.ReadWrite));
Assert.True(stream.CanRead);
Assert.True(stream.CanSeek);
Assert.True(stream.CanWrite);
Assert.Equal(1, stream.Length);
Assert.Equal(4, stream.Capacity);
Assert.Equal(0, stream.Position);
Assert.Throws<InvalidOperationException>(() => stream.ReadTimeout);
Assert.Throws<InvalidOperationException>(() => stream.ReadTimeout = 42);
Assert.Throws<InvalidOperationException>(() => stream.WriteTimeout);
Assert.Throws<InvalidOperationException>(() => stream.WriteTimeout = 42);
Assert.True(stream.PositionPointer == pByte);
}
}
public unsafe UmsManager(FileAccess access, byte[] seedData)
{
int memorySizeInBytes = seedData.Length;
_memory = Marshal.AllocHGlobal(memorySizeInBytes);
byte* destination = (byte*)_memory.ToPointer();
fixed (byte* source = seedData)
{
Buffer.MemoryCopy(source, destination, memorySizeInBytes, memorySizeInBytes);
}
_stream = new UnmanagedMemoryStream(destination, memorySizeInBytes, memorySizeInBytes, access);
}
static void VerifyNothingCanBeReadOrWritten(UnmanagedMemoryStream stream, Byte[] data)
{
// No Read
int count = stream.Read(data, 0, data.Length);
Assert.Equal(0, count);
Assert.Equal(-1, stream.ReadByte());
// No write
Assert.Throws<NotSupportedException>(() => stream.Write(data, 0, data.Length)); // Stream does not support writing.
Assert.Throws<NotSupportedException>(() => stream.WriteByte(Byte.MaxValue)); // Stream does not support writing.
}
public static void CheckStreamIntegrity(UnmanagedMemoryStream stream, Byte[] originalData)
{
stream.Position = 0;
Byte[] streamData = new Byte[originalData.Length];
int value = stream.Read(streamData, 0, streamData.Length);
Assert.Equal(originalData.Length, value);
Assert.Equal(originalData, streamData, ArrayHelpers.Comparer<byte>());
stream.Position = 0;
}
public static void CheckStreamIntegrity(UnmanagedMemoryStream stream, Byte[] originalData)
{
stream.Position = 0;
Byte[] streamData = new Byte[originalData.Length];
int value = stream.Read(streamData, 0, streamData.Length);
Assert.Equal(originalData.Length, value);
for (int i = 0; i < originalData.Length; i++)
Assert.Equal(originalData[i], streamData[i]);
stream.Position = 0;
}
public unsafe UmsManager(FileAccess access, int capacity)
{
int memorySizeInBytes = capacity;
_memory = Marshal.AllocHGlobal(memorySizeInBytes);
byte* bytes = (byte*)_memory.ToPointer();
byte* currentByte = bytes;
for (int index = 0; index < memorySizeInBytes; index++)
{
*currentByte = 0;
currentByte++;
}
_stream = new UnmanagedMemoryStream(bytes, memorySizeInBytes, memorySizeInBytes, access);
}
public static void CannotReadFromWriteStream()
{
using (var manager = new UmsManager(FileAccess.Write, 100))
{
Stream stream = manager.Stream;
Assert.Throws<NotSupportedException>(() => stream.ReadByte());
}
using (HGlobalSafeBuffer buffer = new HGlobalSafeBuffer(100))
using (var stream = new UnmanagedMemoryStream(buffer, 0, 100, FileAccess.Write))
{
Assert.Throws<NotSupportedException>(() => stream.ReadByte());
}
}
public unsafe UmsManager(FileAccess access, byte[] seedData)
{
_memorySizeInBytes = seedData.Length;
unsafe
{
_memory = Marshal.AllocHGlobal(_memorySizeInBytes);
byte* bytes = (byte*)_memory.ToPointer();
byte* currentByte = bytes;
for (int index = 0; index < _memorySizeInBytes; index++)
{
*currentByte = seedData[index];
}
_stream = new UnmanagedMemoryStream(bytes, _memorySizeInBytes, _memorySizeInBytes, access);
}
}
public static unsafe void Main()
{
int prot = 0x1 | 0x2 | 0x4; //PROT_READ | PROT_WRITE | PROT_EXEC
int flags = 0x1000 | 0x0002; //MAP_ANON | MAP_PRIVATE
var res = mmap (IntPtr.Zero, (IntPtr)4096, prot , flags, 0);
var mem = new UnmanagedMemoryStream ((byte*)res, 4096, 4096, FileAccess.ReadWrite);
var asm = new Assembler (mem);
asm.Push (EBP);
asm.Mov (EBP, ESP);
asm.Mov (EAX, 10);
asm.Leave ();
asm.Ret ();
NoArgsReturnInt dele = (NoArgsReturnInt)Marshal.GetDelegateForFunctionPointer (res, typeof (NoArgsReturnInt));
Console.WriteLine (dele ());
}
public static unsafe void CtorsThatFail()
{
Assert.Throws<ArgumentNullException>(() => { var ums = new UnmanagedMemoryStream(null, 0); });
TestSafeBuffer nullBuffer = null;
FakeSafeBuffer fakeBuffer = new FakeSafeBuffer(99);
Assert.Throws<ArgumentNullException>(() => new UnmanagedMemoryStream(nullBuffer, 0, 1));
Assert.Throws<ArgumentOutOfRangeException>(() => new UnmanagedMemoryStream(fakeBuffer, 2, -1));
Assert.Throws<ArgumentOutOfRangeException>(() => new UnmanagedMemoryStream(fakeBuffer, -1, 1));
Assert.Throws<ArgumentOutOfRangeException>(() => new UnmanagedMemoryStream(fakeBuffer, 1, 2, (FileAccess)(-1)));
Assert.Throws<ArgumentOutOfRangeException>(() => new UnmanagedMemoryStream(fakeBuffer, 1, 2, (FileAccess)42));
Assert.Throws<ArgumentException>(() => new UnmanagedMemoryStream(fakeBuffer, 2, 999));
Assert.Throws<ArgumentException>(() => new UnmanagedMemoryStream(fakeBuffer, 999, 9));
Assert.Throws<ArgumentException>(() => new UnmanagedMemoryStream(fakeBuffer, 1, 100));
Assert.Throws<ArgumentException>(() => new UnmanagedMemoryStream(fakeBuffer, Int32.MaxValue, 1));
}
public static void EmptyStreamRead()
{
using (var manager = new UmsManager(FileAccess.Read, 0))
{
UnmanagedMemoryStream stream = manager.Stream;
UmsTests.ReadUmsInvariants(stream);
var position = stream.Position;
Assert.Equal(manager.Stream.ReadByte(), -1); // end of stream
Assert.Equal(stream.Position, position);
}
using (HGlobalSafeBuffer buffer = new HGlobalSafeBuffer(1))
using (var stream = new UnmanagedMemoryStream(buffer, 0, 0))
{
var position = stream.Position;
Assert.Equal(stream.ReadByte(), -1); // end of stream
Assert.Equal(stream.Position, position);
}
}
public static void PointerCtor()
{
int someInt32 = 42;
unsafe
{
int* pInt32 = &someInt32;
byte* pByte = (byte*)pInt32;
using (var stream = new UnmanagedMemoryStream(pByte, 0))
{
Assert.True(stream.CanRead);
Assert.True(stream.CanSeek);
Assert.False(stream.CanWrite);
Assert.Equal(0, stream.Length);
Assert.Equal(0, stream.Capacity);
Assert.Equal(0, stream.Position);
if (stream.PositionPointer != pByte)
{
Assert.True(false);
}
}
}
}
protected unsafe void InitDna(byte[] bdnaOrg)
{
if (_dna != IntPtr.Zero)
{
return;
}
_dnaLength = bdnaOrg.Length;
_dna = Marshal.AllocHGlobal(bdnaOrg.Length);
Marshal.Copy(bdnaOrg, 0, _dna, _dnaLength);
Stream stream = new UnmanagedMemoryStream((byte *)_dna.ToPointer(), _dnaLength);
BinaryReader reader = new BinaryReader(stream);
// SDNA
byte[] code = reader.ReadBytes(8);
string codes = ASCIIEncoding.ASCII.GetString(code);
// NAME
if (!codes.Equals("SDNANAME"))
{
throw new InvalidDataException();
}
int dataLen = reader.ReadInt32();
_names = new Dna.NameInfo[dataLen];
for (int i = 0; i < dataLen; i++)
{
List <byte> name = new List <byte>();
byte ch = reader.ReadByte();
while (ch != 0)
{
name.Add(ch);
ch = reader.ReadByte();
}
_names[i] = new Dna.NameInfo(ASCIIEncoding.ASCII.GetString(name.ToArray()));
}
stream.Position = (stream.Position + 3) & ~3;
// TYPE
code = reader.ReadBytes(4);
codes = ASCIIEncoding.ASCII.GetString(code);
if (!codes.Equals("TYPE"))
{
throw new InvalidDataException();
}
dataLen = reader.ReadInt32();
_types = new Dna.TypeDecl[dataLen];
for (int i = 0; i < dataLen; i++)
{
List <byte> name = new List <byte>();
byte ch = reader.ReadByte();
while (ch != 0)
{
name.Add(ch);
ch = reader.ReadByte();
}
string type = ASCIIEncoding.ASCII.GetString(name.ToArray());
_types[i] = new Dna.TypeDecl(type);
}
stream.Position = (stream.Position + 3) & ~3;
// TLEN
code = reader.ReadBytes(4);
codes = ASCIIEncoding.ASCII.GetString(code);
if (!codes.Equals("TLEN"))
{
throw new InvalidDataException();
}
for (int i = 0; i < _types.Length; i++)
{
_types[i].Length = reader.ReadInt16();
}
stream.Position = (stream.Position + 3) & ~3;
// STRC
code = reader.ReadBytes(4);
codes = ASCIIEncoding.ASCII.GetString(code);
if (!codes.Equals("STRC"))
{
throw new InvalidDataException();
}
dataLen = reader.ReadInt32();
_structs = new Dna.StructDecl[dataLen];
long shtPtr = stream.Position;
for (int i = 0; i < dataLen; i++)
{
Dna.StructDecl structDecl = new Dna.StructDecl();
_structs[i] = structDecl;
if (!BitConverter.IsLittleEndian)
{
throw new NotImplementedException();
}
else
{
short typeNr = reader.ReadInt16();
structDecl.Type = _types[typeNr];
structDecl.Type.Struct = structDecl;
int numElements = reader.ReadInt16();
structDecl.Elements = new Dna.ElementDecl[numElements];
for (int j = 0; j < numElements; j++)
{
typeNr = reader.ReadInt16();
short nameNr = reader.ReadInt16();
structDecl.Elements[j] = new Dna.ElementDecl(_types[typeNr], _names[nameNr]);
}
}
}
reader.Dispose();
stream.Dispose();
// build reverse lookups
_structReverse = new Dictionary <string, Dna.StructDecl>(_structs.Length);
foreach (Dna.StructDecl s in _structs)
{
_structReverse.Add(s.Type.Name, s);
}
}
protected override void Write(UnmanagedMemoryStream stream, byte[] array, int offset, int count) => stream.WriteAsync(new Memory <byte>(array, offset, count)).GetAwaiter().GetResult();
private static DataBox CreateDataBox(SafeUnmanagedArray array, UnmanagedMemoryStream input, Int32 rowPitch, Int32 depthPitch)
{
return(new DataBox(new IntPtr(array.DangerousGetHandle().ToInt64() + input.Position), rowPitch, depthPitch));
}
protected override int Read(UnmanagedMemoryStream stream, byte[] array, int offset, int count) => stream.Read(new Span <byte>(array, offset, count));
protected abstract int Read(UnmanagedMemoryStream stream, byte[] array, int offset, int count);
public static void CopyToTest()
{
byte[] testData = ArrayHelpers.CreateByteArray(8192);
using (var manager = new UmsManager(FileAccess.Read, testData))
{
UnmanagedMemoryStream ums = manager.Stream;
UmsTests.ReadUmsInvariants(ums);
MemoryStream destination = new MemoryStream();
destination.Position = 0;
ums.CopyTo(destination);
Assert.Equal(testData, destination.ToArray());
destination.Position = 0;
ums.CopyTo(destination, 1);
Assert.Equal(testData, destination.ToArray());
}
// copy to disposed stream should throw
using (var manager = new UmsManager(FileAccess.Read, testData))
{
UnmanagedMemoryStream ums = manager.Stream;
UmsTests.ReadUmsInvariants(ums);
MemoryStream destination = new MemoryStream();
destination.Dispose();
Assert.Throws <ObjectDisposedException>(() => ums.CopyTo(destination));
}
// copy from disposed stream should throw
using (var manager = new UmsManager(FileAccess.Read, testData))
{
UnmanagedMemoryStream ums = manager.Stream;
UmsTests.ReadUmsInvariants(ums);
ums.Dispose();
MemoryStream destination = new MemoryStream();
Assert.Throws <ObjectDisposedException>(() => ums.CopyTo(destination));
}
// copying to non-writable stream should throw
using (var manager = new UmsManager(FileAccess.Read, testData))
{
UnmanagedMemoryStream ums = manager.Stream;
UmsTests.ReadUmsInvariants(ums);
MemoryStream destination = new MemoryStream(new byte[0], false);
Assert.Throws <NotSupportedException>(() => ums.CopyTo(destination));
}
// copying from non-readable stream should throw
using (var manager = new UmsManager(FileAccess.Write, testData))
{
UnmanagedMemoryStream ums = manager.Stream;
UmsTests.WriteUmsInvariants(ums);
MemoryStream destination = new MemoryStream(new byte[0], false);
Assert.Throws <NotSupportedException>(() => ums.CopyTo(destination));
}
}
public static unsafe byte[] ConvertDDS(Stream ddsSteam, DXGI_FORMAT targetFormat, ImageFormat imageFormat, int frame)
{
try {
CoInitializeEx(IntPtr.Zero, CoInit.MultiThreaded | CoInit.SpeedOverMemory);
byte[] data = new byte[ddsSteam.Length];
ddsSteam.Read(data, 0, data.Length);
ScratchImage scratch = null;
try
{
fixed(byte *dataPin = data)
{
scratch = TexHelper.Instance.LoadFromDDSMemory((IntPtr)dataPin, data.Length, DDS_FLAGS.NONE);
TexMetadata info = scratch.GetMetadata();
if (TexHelper.Instance.IsCompressed(info.Format))
{
ScratchImage temp = scratch.Decompress(frame, DXGI_FORMAT.UNKNOWN);
scratch.Dispose();
scratch = temp;
}
info = scratch.GetMetadata();
if (info.Format != targetFormat)
{
ScratchImage temp = scratch.Convert(targetFormat, TEX_FILTER_FLAGS.DEFAULT, 0.5f);
scratch.Dispose();
scratch = temp;
}
UnmanagedMemoryStream stream = null;
if (imageFormat == ImageFormat.TGA)
{
stream = scratch.SaveToTGAMemory(frame < 0 ? 0 : frame);
}
else
{
WICCodecs codec = WICCodecs.PNG;
bool isMultiFrame = false;
switch (imageFormat)
{
case ImageFormat.BMP:
codec = WICCodecs.BMP;
break;
case ImageFormat.GIF:
codec = WICCodecs.GIF;
isMultiFrame = true;
break;
case ImageFormat.JPEG:
codec = WICCodecs.JPEG;
break;
case ImageFormat.PNG:
codec = WICCodecs.PNG;
break;
case ImageFormat.TIF:
codec = WICCodecs.TIFF;
isMultiFrame = true;
break;
case ImageFormat.TGA:
break;
default:
throw new ArgumentOutOfRangeException(nameof(imageFormat), imageFormat, null);
}
if (frame < 0)
{
if (!isMultiFrame)
{
frame = 0;
}
else
{
stream = scratch.SaveToWICMemory(0, info.ArraySize, WIC_FLAGS.ALL_FRAMES, TexHelper.Instance.GetWICCodec(codec));
}
}
if (frame >= 0)
{
stream = scratch.SaveToWICMemory(frame, WIC_FLAGS.NONE, TexHelper.Instance.GetWICCodec(codec));
}
}
if (stream == null)
{
return(null);
}
byte[] tex = new byte[stream.Length];
stream.Read(tex, 0, tex.Length);
scratch.Dispose();
return(tex);
}
} catch {
if (scratch != null && scratch.IsDisposed == false)
{
scratch.Dispose();
}
}
} catch {
// ignored
}
return(null);
}
private object DeserializeObject(int typeIndex)
{
Type type = FindType(typeIndex);
if (_assumeBinaryFormatter)
{
return(ReadBinaryFormattedObject());
}
// read type
SerializationFormat format = (SerializationFormat)_store.Read7BitEncodedInt();
object value;
// read data
switch (format)
{
case SerializationFormat.BinaryFormatter:
{
// read length
int length = _store.Read7BitEncodedInt();
if (length < 0)
{
throw new BadImageFormatException(SR.Format(SR.BadImageFormat_ResourceDataLengthInvalid, length));
}
long originalPosition = _store.BaseStream.Position;
value = ReadBinaryFormattedObject();
if (type == typeof(UnknownType))
{
// type information was omitted at the time of writing
// allow the payload to define the type
type = value.GetType();
}
long bytesRead = _store.BaseStream.Position - originalPosition;
// Ensure BF read what we expected.
if (bytesRead != length)
{
throw new BadImageFormatException(SR.Format(SR.BadImageFormat_ResourceDataLengthInvalid, length));
}
break;
}
case SerializationFormat.TypeConverterByteArray:
{
// read length
int length = _store.Read7BitEncodedInt();
if (length < 0)
{
throw new BadImageFormatException(SR.Format(SR.BadImageFormat_ResourceDataLengthInvalid, length));
}
byte[] data = _store.ReadBytes(length);
TypeConverter converter = TypeDescriptor.GetConverter(type);
if (converter == null)
{
throw new TypeLoadException(SR.Format(SR.TypeLoadException_CannotLoadConverter, type));
}
value = converter.ConvertFrom(data);
break;
}
case SerializationFormat.TypeConverterString:
{
string stringData = _store.ReadString();
TypeConverter converter = TypeDescriptor.GetConverter(type);
if (converter == null)
{
throw new TypeLoadException(SR.Format(SR.TypeLoadException_CannotLoadConverter, type));
}
value = converter.ConvertFromInvariantString(stringData);
break;
}
case SerializationFormat.ActivatorStream:
{
// read length
int length = _store.Read7BitEncodedInt();
if (length < 0)
{
throw new BadImageFormatException(SR.Format(SR.BadImageFormat_ResourceDataLengthInvalid, length));
}
Stream stream;
if (_store.BaseStream is UnmanagedMemoryStream ums)
{
// For the case that we've memory mapped in the .resources
// file, just return a Stream pointing to that block of memory.
unsafe
{
stream = new UnmanagedMemoryStream(ums.PositionPointer, length, length, FileAccess.Read);
}
}
else
{
byte[] bytes = _store.ReadBytes(length);
// Lifetime of memory == lifetime of this stream.
stream = new MemoryStream(bytes, false);
}
value = Activator.CreateInstance(type, new object[] { stream });
break;
}
default:
throw new BadImageFormatException(SR.BadImageFormat_TypeMismatch);
}
// Make sure we deserialized the type that we expected.
// This protects against bad typeconverters or bad binaryformatter payloads.
if (value.GetType() != type)
{
throw new BadImageFormatException(SR.Format(SR.BadImageFormat_ResType_SerBlobMismatch, type.FullName, value.GetType().FullName));
}
return(value);
}
public KeysSoundEffects(ILog log, UnmanagedMemoryStream key1Sound, UnmanagedMemoryStream key2Sound, UnmanagedMemoryStream crtlSound, UnmanagedMemoryStream shiftSound, UnmanagedMemoryStream winSound,
UnmanagedMemoryStream rightAltSound, UnmanagedMemoryStream leftAltSound = null)
{
logger = log;
FirstKeySound = key1Sound;
SecondKeySound = key2Sound;
CrtlActionSound = crtlSound;
ShiftActionSound = shiftSound;
WinActionSound = winSound;
AltActionSound = rightAltSound;
}
public static void SeekTests()
{
const int length = 1000;
using (var manager = new UmsManager(FileAccess.ReadWrite, length))
{
UnmanagedMemoryStream stream = manager.Stream;
UmsTests.ReadWriteUmsInvariants(stream);
Assert.Throws <IOException>(() => stream.Seek(unchecked (int.MaxValue + 1), SeekOrigin.Begin));
Assert.Throws <IOException>(() => stream.Seek(long.MinValue, SeekOrigin.End));
AssertExtensions.Throws <ArgumentException>(null, () => stream.Seek(0, (SeekOrigin)7)); // Invalid seek origin
stream.Seek(10, SeekOrigin.Begin);
Assert.Equal(10, stream.Position);
Assert.Throws <IOException>(() => stream.Seek(-1, SeekOrigin.Begin)); // An attempt was made to move the position before the beginning of the stream
Assert.Equal(10, stream.Position);
Assert.Throws <IOException>(() => stream.Seek(-(stream.Position + 1), SeekOrigin.Current)); // An attempt was made to move the position before the beginning of the stream
Assert.Equal(10, stream.Position);
Assert.Throws <IOException>(() => stream.Seek(-(stream.Length + 1), SeekOrigin.End)); // "An attempt was made to move the position before the beginning of the stream."
Assert.Equal(10, stream.Position);
// Seek from SeekOrigin.Begin
stream.Seek(0, SeekOrigin.Begin);
for (int position = 0; position < stream.Length; position++)
{
stream.Seek(position, SeekOrigin.Begin);
Assert.Equal(position, stream.Position);
}
for (int position = (int)stream.Length; position >= 0; position--)
{
stream.Seek(position, SeekOrigin.Begin);
Assert.Equal(position, stream.Position);
}
stream.Seek(0, SeekOrigin.Begin);
// Seek from SeekOrigin.End
for (int position = 0; position < stream.Length; position++)
{
stream.Seek(-position, SeekOrigin.End);
Assert.Equal(length - position, stream.Position);
}
for (int position = (int)stream.Length; position >= 0; position--)
{
stream.Seek(-position, SeekOrigin.End);
Assert.Equal(length - position, stream.Position);
}
// Seek from SeekOrigin.Current
stream.Seek(0, SeekOrigin.Begin);
for (int position = 0; position < stream.Length; position++)
{
stream.Seek(1, SeekOrigin.Current);
Assert.Equal(position + 1, stream.Position);
}
for (int position = (int)stream.Length; position > 0; position--)
{
stream.Seek(-1, SeekOrigin.Current);
Assert.Equal(position - 1, stream.Position);
}
}
}
public static async Task CopyToAsyncTest()
{
byte[] testData = ArrayHelpers.CreateByteArray(8192);
using (var manager = new UmsManager(FileAccess.Read, testData))
{
UnmanagedMemoryStream ums = manager.Stream;
UmsTests.ReadUmsInvariants(ums);
MemoryStream destination = new MemoryStream();
destination.Position = 0;
await ums.CopyToAsync(destination);
Assert.Equal(testData, destination.ToArray());
destination.Position = 0;
await ums.CopyToAsync(destination, 2);
Assert.Equal(testData, destination.ToArray());
destination.Position = 0;
await ums.CopyToAsync(destination, 0x1000, new CancellationTokenSource().Token);
Assert.Equal(testData, destination.ToArray());
await Assert.ThrowsAnyAsync <OperationCanceledException>(() => ums.CopyToAsync(destination, 0x1000, new CancellationToken(true)));
}
// copy to disposed stream should throw
using (var manager = new UmsManager(FileAccess.Read, testData))
{
UnmanagedMemoryStream ums = manager.Stream;
UmsTests.ReadUmsInvariants(ums);
MemoryStream destination = new MemoryStream();
destination.Dispose();
await Assert.ThrowsAsync <ObjectDisposedException>(() => ums.CopyToAsync(destination));
}
// copy from disposed stream should throw
using (var manager = new UmsManager(FileAccess.Read, testData))
{
UnmanagedMemoryStream ums = manager.Stream;
UmsTests.ReadUmsInvariants(ums);
ums.Dispose();
MemoryStream destination = new MemoryStream();
await Assert.ThrowsAsync <ObjectDisposedException>(() => ums.CopyToAsync(destination));
}
// copying to non-writable stream should throw
using (var manager = new UmsManager(FileAccess.Read, testData))
{
UnmanagedMemoryStream ums = manager.Stream;
UmsTests.ReadUmsInvariants(ums);
MemoryStream destination = new MemoryStream(new byte[0], false);
await Assert.ThrowsAsync <NotSupportedException>(() => ums.CopyToAsync(destination));
}
// copying from non-readable stream should throw
using (var manager = new UmsManager(FileAccess.Write, testData))
{
UnmanagedMemoryStream ums = manager.Stream;
UmsTests.WriteUmsInvariants(ums);
MemoryStream destination = new MemoryStream(new byte[0], false);
await Assert.ThrowsAsync <NotSupportedException>(() => ums.CopyToAsync(destination));
}
}
/// <summary>
/// Decodes a jpeg image
/// </summary>
/// <param name="jpeg">The stream that contains the jpeg data</param>
public void Decode(UnmanagedMemoryStream jpeg)
{
Decode(jpeg.PositionPointer, (int)jpeg.Length, false);
}
public static unsafe void Initialize()
{
Module mod = typeof(AntiTamperJIT).Module;
IntPtr modPtr = Marshal.GetHINSTANCE(mod);
s = (ulong)modPtr.ToInt64();
if (modPtr == (IntPtr)(-1)) Environment.FailFast(null);
string fq = mod.FullyQualifiedName;
bool mapped = fq[0] != '<'; //<Unknown>
Stream stream;
stream = new UnmanagedMemoryStream((byte*)modPtr.ToPointer(), 0xfffffff, 0xfffffff, FileAccess.ReadWrite);
byte[] buff;
int checkSumOffset;
ulong checkSum;
byte[] iv;
byte[] dats;
int sn;
int snLen;
using (BinaryReader rdr = new BinaryReader(stream))
{
stream.Seek(0x3c, SeekOrigin.Begin);
uint offset = rdr.ReadUInt32();
stream.Seek(offset, SeekOrigin.Begin);
stream.Seek(0x6, SeekOrigin.Current);
uint sections = rdr.ReadUInt16();
stream.Seek(0xC, SeekOrigin.Current);
uint optSize = rdr.ReadUInt16();
stream.Seek(offset = offset + 0x18, SeekOrigin.Begin); //Optional hdr
bool pe32 = (rdr.ReadUInt16() == 0x010b);
stream.Seek(0x3e, SeekOrigin.Current);
checkSumOffset = (int)stream.Position;
uint md = rdr.ReadUInt32() ^ (uint)Mutation.Key0I;
if (md == (uint)Mutation.Key0I)
return;
stream.Seek(offset = offset + optSize, SeekOrigin.Begin); //sect hdr
uint datLoc = 0;
for (int i = 0; i < sections; i++)
{
int h = 0;
for (int j = 0; j < 8; j++)
{
byte chr = rdr.ReadByte();
if (chr != 0) h += chr;
}
uint vSize = rdr.ReadUInt32();
uint vLoc = rdr.ReadUInt32();
uint rSize = rdr.ReadUInt32();
uint rLoc = rdr.ReadUInt32();
if (h == Mutation.Key1I)
datLoc = mapped ? vLoc : rLoc;
if (!mapped && md > vLoc && md < vLoc + vSize)
md = md - vLoc + rLoc;
if (mapped && vSize + vLoc > l) l = vSize + vLoc;
else if (rSize + rLoc > l) l = rSize + rLoc;
stream.Seek(0x10, SeekOrigin.Current);
}
stream.Seek(md, SeekOrigin.Begin);
using (MemoryStream str = new MemoryStream())
{
stream.Position += 12;
stream.Position += rdr.ReadUInt32() + 4;
stream.Position += 2;
ushort streams = rdr.ReadUInt16();
for (int i = 0; i < streams; i++)
{
uint pos = rdr.ReadUInt32() + md;
uint size = rdr.ReadUInt32();
int c = 0;
while (rdr.ReadByte() != 0) c++;
long ori = stream.Position += (((c + 1) + 3) & ~3) - (c + 1);
stream.Position = pos;
str.Write(rdr.ReadBytes((int)size), 0, (int)size);
stream.Position = ori;
}
buff = str.ToArray();
}
stream.Seek(datLoc, SeekOrigin.Begin);
checkSum = rdr.ReadUInt64() ^ (ulong)Mutation.Key0L;
sn = rdr.ReadInt32();
snLen = rdr.ReadInt32();
iv = rdr.ReadBytes(rdr.ReadInt32() ^ Mutation.Key2I);
dats = rdr.ReadBytes(rdr.ReadInt32() ^ Mutation.Key3I);
}
byte[] md5 = MD5.Create().ComputeHash(buff);
ulong tCs = BitConverter.ToUInt64(md5, 0) ^ BitConverter.ToUInt64(md5, 8);
ulong* msg = stackalloc ulong[2];
msg[0] = 0x6574707572726f43; //Corrupte
msg[1] = 0x0021656c69662064; //d file!.
if (tCs != checkSum)
Environment.FailFast(new string((sbyte*)msg));
byte[] b = Decrypt(buff, iv, dats);
Buffer.BlockCopy(new byte[buff.Length], 0, buff, 0, buff.Length);
if (b[0] != 0xd6 || b[1] != 0x6f)
Environment.FailFast(new string((sbyte*)msg));
byte[] dat = new byte[b.Length - 2];
Buffer.BlockCopy(b, 2, dat, 0, dat.Length);
data = dat;
Hook();
//AppDomain.CurrentDomain.ProcessExit += Dispose;
}
private static sbyte[] calculateRSECC(sbyte[] codewords, sbyte rsEccCodewords, sbyte[] rsBlockOrder, int maxDataCodewords, int maxCodewords)
{
sbyte[][] rsCalTableArray = new sbyte[256][];
for (int i = 0; i < 256; i++)
{
rsCalTableArray[i] = new sbyte[rsEccCodewords];
}
try
{
//String filename = QRCODE_DATA_PATH + @"\rsc" + rsEccCodewords.ToString() + ".dat";
//StreamReader reader = new StreamReader(filename);
String fileName = "rsc" + rsEccCodewords.ToString();
UnmanagedMemoryStream memoryStream = Resources.ResourceManager.GetStream(fileName);
BufferedStream bis = new BufferedStream(memoryStream);
for (int i = 0; i < 256; i++)
{
SystemUtils.ReadInput(bis, rsCalTableArray[i], 0, rsCalTableArray[i].Length);
}
bis.Close();
//reader.Close();
memoryStream.Close();
}
catch (Exception e)
{
SystemUtils.WriteStackTrace(e, Console.Error);
}
/* ---- RS-ECC prepare */
int i2 = 0;
int j = 0;
int rsBlockNumber = 0;
byte dim2 = Convert.ToByte((rsBlockOrder[rsBlockNumber] & 0xFF) - rsEccCodewords);
sbyte[][] rsTemp = new sbyte[rsBlockOrder.Length][];
/*(
* for (int i = 0; i < rsBlockOrder.Length; i++)
* {
* rsTemp[i] = new sbyte[rsBlockOrder.Length];
* }
*/
sbyte[] res = new sbyte[maxCodewords];
Array.Copy(codewords, 0, res, 0, codewords.Length);
i2 = 0;
while (i2 < rsBlockOrder.Length)
{
rsTemp[i2] = new sbyte[(rsBlockOrder[i2] & 0xFF) - rsEccCodewords];
i2++;
}
i2 = 0;
while (i2 < maxDataCodewords)
{
rsTemp[rsBlockNumber][j] = codewords[i2];
j++;
if (j >= (rsBlockOrder[rsBlockNumber] & 0xFF) - rsEccCodewords)
{
j = 0;
rsBlockNumber++;
}
i2++;
}
/* --- RS-ECC main --- */
rsBlockNumber = 0;
while (rsBlockNumber < rsBlockOrder.Length)
{
sbyte[] rsTempData;
rsTempData = new sbyte[rsTemp[rsBlockNumber].Length];
rsTemp[rsBlockNumber].CopyTo(rsTempData, 0);
int rsCodewords = (rsBlockOrder[rsBlockNumber] & 0xFF);
int rsDataCodewords = rsCodewords - rsEccCodewords;
j = rsDataCodewords;
while (j > 0)
{
sbyte first = rsTempData[0];
if (first != 0)
{
sbyte[] leftChr = new sbyte[rsTempData.Length - 1];
Array.Copy(rsTempData, 1, leftChr, 0, rsTempData.Length - 1);
sbyte[] cal = rsCalTableArray[(first & 0xFF)];
rsTempData = calculateByteArrayBits(leftChr, cal, "xor");
}
else
{
if (rsEccCodewords < rsTempData.Length)
{
sbyte[] rsTempNew = new sbyte[rsTempData.Length - 1];
Array.Copy(rsTempData, 1, rsTempNew, 0, rsTempData.Length - 1);
rsTempData = new sbyte[rsTempNew.Length];
rsTempNew.CopyTo(rsTempData, 0);
}
else
{
sbyte[] rsTempNew = new sbyte[rsEccCodewords];
Array.Copy(rsTempData, 1, rsTempNew, 0, rsTempData.Length - 1);
rsTempNew[rsEccCodewords - 1] = 0;
rsTempData = new sbyte[rsTempNew.Length];
rsTempNew.CopyTo(rsTempData, 0);
}
}
j--;
}
Array.Copy(rsTempData, 0, res, codewords.Length + rsBlockNumber * rsEccCodewords, (byte)rsEccCodewords);
rsBlockNumber++;
}
return(res);
}
internal static void UmsInvariants(UnmanagedMemoryStream stream)
{
Assert.False(stream.CanTimeout);
}
public static unsafe void Initalize()
{
Module mod = typeof(AntiTamperMem).Module;
IntPtr modPtr = Marshal.GetHINSTANCE(mod);
if (modPtr == (IntPtr)(-1)) Environment.FailFast("Module error");
bool mapped = mod.FullyQualifiedName[0] != '<'; //<Unknown>
Stream stream;
stream = new UnmanagedMemoryStream((byte*)modPtr.ToPointer(), 0xfffffff, 0xfffffff, FileAccess.ReadWrite);
byte[] buff;
int checkSumOffset;
ulong checkSum;
byte[] iv;
byte[] dats;
int sn;
int snLen;
using (BinaryReader rdr = new BinaryReader(stream))
{
stream.Seek(0x3c, SeekOrigin.Begin);
uint offset = rdr.ReadUInt32();
stream.Seek(offset, SeekOrigin.Begin);
stream.Seek(0x6, SeekOrigin.Current);
uint sections = rdr.ReadUInt16();
stream.Seek(0xC, SeekOrigin.Current);
uint optSize = rdr.ReadUInt16();
stream.Seek(offset = offset + 0x18, SeekOrigin.Begin); //Optional hdr
bool pe32 = (rdr.ReadUInt16() == 0x010b);
stream.Seek(0x3e, SeekOrigin.Current);
checkSumOffset = (int)stream.Position;
uint md = rdr.ReadUInt32() ^ (uint)Mutation.Key0I;
if (md == (uint)Mutation.Key0I)
Environment.FailFast("Broken file");
stream.Seek(offset = offset + optSize, SeekOrigin.Begin); //sect hdr
uint datLoc = 0;
for (int i = 0; i < sections; i++)
{
int h = 0;
for (int j = 0; j < 8; j++)
{
byte chr = rdr.ReadByte();
if (chr != 0) h += chr;
}
uint vSize = rdr.ReadUInt32();
uint vLoc = rdr.ReadUInt32();
uint rSize = rdr.ReadUInt32();
uint rLoc = rdr.ReadUInt32();
if (h == Mutation.Key1I)
datLoc = mapped ? vLoc : rLoc;
if (!mapped && md > vLoc && md < vLoc + vSize)
md = md - vLoc + rLoc;
stream.Seek(0x10, SeekOrigin.Current);
}
stream.Seek(md, SeekOrigin.Begin);
using (MemoryStream str = new MemoryStream())
{
stream.Position += 12;
stream.Position += rdr.ReadUInt32() + 4;
stream.Position += 2;
ushort streams = rdr.ReadUInt16();
for (int i = 0; i < streams; i++)
{
uint pos = rdr.ReadUInt32() + md;
uint size = rdr.ReadUInt32();
int c = 0;
while (rdr.ReadByte() != 0) c++;
long ori = stream.Position += (((c + 1) + 3) & ~3) - (c + 1);
stream.Position = pos;
str.Write(rdr.ReadBytes((int)size), 0, (int)size);
stream.Position = ori;
}
buff = str.ToArray();
}
stream.Seek(datLoc, SeekOrigin.Begin);
checkSum = rdr.ReadUInt64() ^ (ulong)Mutation.Key0L;
sn = rdr.ReadInt32();
snLen = rdr.ReadInt32();
iv = rdr.ReadBytes(rdr.ReadInt32() ^ Mutation.Key2I);
dats = rdr.ReadBytes(rdr.ReadInt32() ^ Mutation.Key3I);
}
byte[] md5 = MD5.Create().ComputeHash(buff);
ulong tCs = BitConverter.ToUInt64(md5, 0) ^ BitConverter.ToUInt64(md5, 8);
if (tCs != checkSum)
Environment.FailFast("Broken file");
byte[] b = Decrypt(buff, iv, dats);
Buffer.BlockCopy(new byte[buff.Length], 0, buff, 0, buff.Length);
if (b[0] != 0xd6 || b[1] != 0x6f)
Environment.FailFast("Broken file");
byte[] tB = new byte[b.Length - 2];
Buffer.BlockCopy(b, 2, tB, 0, tB.Length);
using (BinaryReader rdr = new BinaryReader(new MemoryStream(tB)))
{
uint len = rdr.ReadUInt32();
int[] codeLens = new int[len];
IntPtr[] ptrs = new IntPtr[len];
for (int i = 0; i < len; i++)
{
uint pos = rdr.ReadUInt32() ^ (uint)Mutation.Key4I;
if (pos == 0) continue;
uint rva = rdr.ReadUInt32() ^ (uint)Mutation.Key5I;
byte[] cDat = rdr.ReadBytes(rdr.ReadInt32());
uint old;
IntPtr ptr = (IntPtr)((uint)modPtr + (mapped ? rva : pos));
VirtualProtect(ptr, (uint)cDat.Length, 0x04, out old);
Marshal.Copy(cDat, 0, ptr, cDat.Length);
VirtualProtect(ptr, (uint)cDat.Length, old, out old);
codeLens[i] = cDat.Length;
ptrs[i] = ptr;
}
//for (int i = 0; i < len; i++)
//{
// if (codeLens[i] == 0) continue;
// RuntimeHelpers.PrepareMethod(mod.ModuleHandle.GetRuntimeMethodHandleFromMetadataToken(0x06000000 + i + 1));
//}
//for (int i = 0; i < len; i++)
//{
// if (codeLens[i] == 0) continue;
// uint old;
// VirtualProtect(ptrs[i], (uint)codeLens[i], 0x04, out old);
// Marshal.Copy(new byte[codeLens[i]], 0, ptrs[i], codeLens[i]);
// VirtualProtect(ptrs[i], (uint)codeLens[i], old, out old);
//}
}
}
public static void ReadWriteByteSafeBuffer()
{
const int length = 1000;
using (var buffer = new TestSafeBuffer(length))
{
var stream = new UnmanagedMemoryStream(buffer, 0, (long)buffer.ByteLength, FileAccess.ReadWrite);
Assert.Equal(stream.Length, length);
var bytes = ArrayHelpers.CreateByteArray(length);
for (int index = 0; index < length; index++)
{
stream.WriteByte(bytes[index]);
}
stream.Position = 0;
for (int index = 0; index < length; index++)
{
int value = stream.ReadByte();
Assert.Equal(bytes[index], (byte)value);
}
var memory = buffer.ToArray();
Assert.Equal(bytes, memory, ArrayHelpers.Comparer<byte>());
}
}
protected abstract void Write(UnmanagedMemoryStream stream, byte[] array, int offset, int count);
private static DataRectangle CreateDataRectangle(SafeUnmanagedArray array, UnmanagedMemoryStream input, Int32 pitch)
{
return(new DataRectangle(new IntPtr(array.DangerousGetHandle().ToInt64() + input.Position), pitch));
}
private static unsafe MD5Hash Hash(byte *ptr, int length)
{
var stream = new UnmanagedMemoryStream(ptr, length);
return(Hash(stream));
}
public virtual bool[][] calQrcode(byte[] qrcodeData)
{
int dataLength;
int dataCounter = 0;
dataLength = qrcodeData.Length;
int[] dataValue = new int[dataLength + 32];
sbyte[] dataBits = new sbyte[dataLength + 32];
if (dataLength <= 0)
{
bool[][] ret = new bool[][] { new bool[] { false } };
return(ret);
}
if (qrcodeStructureappendN > 1)
{
dataValue[0] = 3;
dataBits[0] = 4;
dataValue[1] = qrcodeStructureappendM - 1;
dataBits[1] = 4;
dataValue[2] = qrcodeStructureappendN - 1;
dataBits[2] = 4;
dataValue[3] = qrcodeStructureappendParity;
dataBits[3] = 8;
dataCounter = 4;
}
dataBits[dataCounter] = 4;
/* --- determine encode mode --- */
int[] codewordNumPlus;
int codewordNumCounterValue;
switch (qrcodeEncodeMode)
{
/* ---- alphanumeric mode --- */
case ENCODE_MODE.ALPHA_NUMERIC:
codewordNumPlus = new int[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4 };
dataValue[dataCounter] = 2;
dataCounter++;
dataValue[dataCounter] = dataLength;
dataBits[dataCounter] = 9;
codewordNumCounterValue = dataCounter;
dataCounter++;
for (int i = 0; i < dataLength; i++)
{
char chr = (char)qrcodeData[i];
sbyte chrValue = 0;
if (chr >= 48 && chr < 58)
{
chrValue = (sbyte)(chr - 48);
}
else
{
if (chr >= 65 && chr < 91)
{
chrValue = (sbyte)(chr - 55);
}
else
{
if (chr == 32)
{
chrValue = 36;
}
if (chr == 36)
{
chrValue = 37;
}
if (chr == 37)
{
chrValue = 38;
}
if (chr == 42)
{
chrValue = 39;
}
if (chr == 43)
{
chrValue = 40;
}
if (chr == 45)
{
chrValue = 41;
}
if (chr == 46)
{
chrValue = 42;
}
if (chr == 47)
{
chrValue = 43;
}
if (chr == 58)
{
chrValue = 44;
}
}
}
if ((i % 2) == 0)
{
dataValue[dataCounter] = chrValue;
dataBits[dataCounter] = 6;
}
else
{
dataValue[dataCounter] = dataValue[dataCounter] * 45 + chrValue;
dataBits[dataCounter] = 11;
if (i < dataLength - 1)
{
dataCounter++;
}
}
}
dataCounter++;
break;
/* ---- numeric mode ---- */
case ENCODE_MODE.NUMERIC:
codewordNumPlus = new int[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4 };
dataValue[dataCounter] = 1;
dataCounter++;
dataValue[dataCounter] = dataLength;
dataBits[dataCounter] = 10; /* #version 1-9*/
codewordNumCounterValue = dataCounter;
dataCounter++;
for (int i = 0; i < dataLength; i++)
{
if ((i % 3) == 0)
{
dataValue[dataCounter] = (int)(qrcodeData[i] - 0x30);
dataBits[dataCounter] = 4;
}
else
{
dataValue[dataCounter] = dataValue[dataCounter] * 10 + (int)(qrcodeData[i] - 0x30);
if ((i % 3) == 1)
{
dataBits[dataCounter] = 7;
}
else
{
dataBits[dataCounter] = 10;
if (i < dataLength - 1)
{
dataCounter++;
}
}
}
}
dataCounter++;
break;
/* ---- 8bit byte ---- */
default:
codewordNumPlus = new int[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8 };
dataValue[dataCounter] = 4;
dataCounter++;
dataValue[dataCounter] = dataLength;
dataBits[dataCounter] = 8; /* #version 1-9 */
codewordNumCounterValue = dataCounter;
dataCounter++;
for (int i = 0; i < dataLength; i++)
{
dataValue[i + dataCounter] = (qrcodeData[i] & 0xFF);
dataBits[i + dataCounter] = 8;
}
dataCounter += dataLength;
break;
}
int totalDataBits = 0;
for (int i = 0; i < dataCounter; i++)
{
totalDataBits += dataBits[i];
}
int ec;
switch (qrcodeErrorCorrect)
{
case ERROR_CORRECTION.L:
ec = 1;
break;
case ERROR_CORRECTION.Q:
ec = 3;
break;
case ERROR_CORRECTION.H:
ec = 2;
break;
default:
ec = 0;
break;
}
int[][] maxDataBitsArray = new int[][] { new int[] { 0, 128, 224, 352, 512, 688, 864, 992, 1232, 1456, 1728, 2032, 2320, 2672, 2920, 3320, 3624, 4056, 4504, 5016, 5352, 5712, 6256, 6880, 7312, 8000, 8496, 9024, 9544, 10136, 10984, 11640, 12328, 13048, 13800, 14496, 15312, 15936, 16816, 17728, 18672 }, new int[] { 0, 152, 272, 440, 640, 864, 1088, 1248, 1552, 1856, 2192, 2592, 2960, 3424, 3688, 4184, 4712, 5176, 5768, 6360, 6888, 7456, 8048, 8752, 9392, 10208, 10960, 11744, 12248, 13048, 13880, 14744, 15640, 16568, 17528, 18448, 19472, 20528, 21616, 22496, 23648 }, new int[] { 0, 72, 128, 208, 288, 368, 480, 528, 688, 800, 976, 1120, 1264, 1440, 1576, 1784, 2024, 2264, 2504, 2728, 3080, 3248, 3536, 3712, 4112, 4304, 4768, 5024, 5288, 5608, 5960, 6344, 6760, 7208, 7688, 7888, 8432, 8768, 9136, 9776, 10208 }, new int[] { 0, 104, 176, 272, 384, 496, 608, 704, 880, 1056, 1232, 1440, 1648, 1952, 2088, 2360, 2600, 2936, 3176, 3560, 3880, 4096, 4544, 4912, 5312, 5744, 6032, 6464, 6968, 7288, 7880, 8264, 8920, 9368, 9848, 10288, 10832, 11408, 12016, 12656, 13328 } };
int maxDataBits = 0;
if (qrcodeVersion == 0)
{
/* auto version select */
qrcodeVersion = 1;
for (int i = 1; i <= 40; i++)
{
if ((maxDataBitsArray[ec][i]) >= totalDataBits + codewordNumPlus[qrcodeVersion])
{
maxDataBits = maxDataBitsArray[ec][i];
break;
}
qrcodeVersion++;
}
}
else
{
maxDataBits = maxDataBitsArray[ec][qrcodeVersion];
}
totalDataBits += codewordNumPlus[qrcodeVersion];
dataBits[codewordNumCounterValue] = (sbyte)(dataBits[codewordNumCounterValue] + codewordNumPlus[qrcodeVersion]);
int[] maxCodewordsArray = new int[] { 0, 26, 44, 70, 100, 134, 172, 196, 242, 292, 346, 404, 466, 532, 581, 655, 733, 815, 901, 991, 1085, 1156, 1258, 1364, 1474, 1588, 1706, 1828, 1921, 2051, 2185, 2323, 2465, 2611, 2761, 2876, 3034, 3196, 3362, 3532, 3706 };
int maxCodewords = maxCodewordsArray[qrcodeVersion];
int maxModules1side = 17 + (qrcodeVersion << 2);
int[] matrixRemainBit = new int[] { 0, 0, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0 };
/* ---- read version ECC data file */
int byte_num = matrixRemainBit[qrcodeVersion] + (maxCodewords << 3);
sbyte[] matrixX = new sbyte[byte_num];
sbyte[] matrixY = new sbyte[byte_num];
sbyte[] maskArray = new sbyte[byte_num];
sbyte[] formatInformationX2 = new sbyte[15];
sbyte[] formatInformationY2 = new sbyte[15];
sbyte[] rsEccCodewords = new sbyte[1];
sbyte[] rsBlockOrderTemp = new sbyte[128];
try
{
//String filename = QRCODE_DATA_PATH + @"\qrv" + System.Convert.ToString(qrcodeVersion) + "_" + System.Convert.ToString(ec) + ".dat";
//StreamReader reader = new StreamReader(filename);
//BufferedStream bis = new BufferedStream(reader.BaseStream);
String fileName = "qrv" + Convert.ToString(qrcodeVersion) + "_" + Convert.ToString(ec);
UnmanagedMemoryStream memoryStream = Resources.ResourceManager.GetStream(fileName);
BufferedStream bis = new BufferedStream(memoryStream);
SystemUtils.ReadInput(bis, matrixX, 0, matrixX.Length);
SystemUtils.ReadInput(bis, matrixY, 0, matrixY.Length);
SystemUtils.ReadInput(bis, maskArray, 0, maskArray.Length);
SystemUtils.ReadInput(bis, formatInformationX2, 0, formatInformationX2.Length);
SystemUtils.ReadInput(bis, formatInformationY2, 0, formatInformationY2.Length);
SystemUtils.ReadInput(bis, rsEccCodewords, 0, rsEccCodewords.Length);
SystemUtils.ReadInput(bis, rsBlockOrderTemp, 0, rsBlockOrderTemp.Length);
bis.Close();
memoryStream.Close();
// reader.Close();
/*
* fis.Close();
*/
}
catch (Exception e)
{
SystemUtils.WriteStackTrace(e, Console.Error);
}
sbyte rsBlockOrderLength = 1;
for (sbyte i = 1; i < 128; i++)
{
if (rsBlockOrderTemp[i] == 0)
{
rsBlockOrderLength = i;
break;
}
}
sbyte[] rsBlockOrder = new sbyte[rsBlockOrderLength];
Array.Copy(rsBlockOrderTemp, 0, rsBlockOrder, 0, (byte)rsBlockOrderLength);
sbyte[] formatInformationX1 = new sbyte[] { 0, 1, 2, 3, 4, 5, 7, 8, 8, 8, 8, 8, 8, 8, 8 };
sbyte[] formatInformationY1 = new sbyte[] { 8, 8, 8, 8, 8, 8, 8, 8, 7, 5, 4, 3, 2, 1, 0 };
int maxDataCodewords = maxDataBits >> 3;
/* -- read frame data -- */
int modules1Side = 4 * qrcodeVersion + 17;
int matrixTotalBits = modules1Side * modules1Side;
sbyte[] frameData = new sbyte[matrixTotalBits + modules1Side];
try
{
//String filename = QRCODE_DATA_PATH + "/qrvfr" + System.Convert.ToString(qrcodeVersion) + ".dat";
//StreamReader reader = new StreamReader(filename);
String fileName = "qrvfr" + Convert.ToString(qrcodeVersion);
UnmanagedMemoryStream memoryStream = Resources.ResourceManager.GetStream(fileName);
BufferedStream bis = new BufferedStream(memoryStream);
SystemUtils.ReadInput(bis, frameData, 0, frameData.Length);
bis.Close();
memoryStream.Close();
//reader.Close();
//fis.Close();
}
catch (Exception e)
{
SystemUtils.WriteStackTrace(e, Console.Error);
}
/* --- set terminator */
if (totalDataBits <= maxDataBits - 4)
{
dataValue[dataCounter] = 0;
dataBits[dataCounter] = 4;
}
else
{
if (totalDataBits < maxDataBits)
{
dataValue[dataCounter] = 0;
dataBits[dataCounter] = (sbyte)(maxDataBits - totalDataBits);
}
else
{
if (totalDataBits > maxDataBits)
{
System.Console.Out.WriteLine("overflow");
}
}
}
sbyte[] dataCodewords = divideDataBy8Bits(dataValue, dataBits, maxDataCodewords);
sbyte[] codewords = calculateRSECC(dataCodewords, rsEccCodewords[0], rsBlockOrder, maxDataCodewords, maxCodewords);
/* ---- flash matrix */
sbyte[][] matrixContent = new sbyte[modules1Side][];
for (int i2 = 0; i2 < modules1Side; i2++)
{
matrixContent[i2] = new sbyte[modules1Side];
}
for (int i = 0; i < modules1Side; i++)
{
for (int j = 0; j < modules1Side; j++)
{
matrixContent[j][i] = 0;
}
}
/* --- attach data */
for (int i = 0; i < maxCodewords; i++)
{
sbyte codeword_i = codewords[i];
for (int j = 7; j >= 0; j--)
{
int codewordBitsNumber = (i * 8) + j;
matrixContent[matrixX[codewordBitsNumber] & 0xFF][matrixY[codewordBitsNumber] & 0xFF] = (sbyte)((255 * (codeword_i & 1)) ^ maskArray[codewordBitsNumber]);
codeword_i = (sbyte)(SystemUtils.URShift((codeword_i & 0xFF), 1));
}
}
for (int matrixRemain = matrixRemainBit[qrcodeVersion]; matrixRemain > 0; matrixRemain--)
{
int remainBitTemp = matrixRemain + (maxCodewords * 8) - 1;
matrixContent[matrixX[remainBitTemp] & 0xFF][matrixY[remainBitTemp] & 0xFF] = (sbyte)(255 ^ maskArray[remainBitTemp]);
}
/* --- mask select --- */
sbyte maskNumber = selectMask(matrixContent, matrixRemainBit[qrcodeVersion] + maxCodewords * 8);
sbyte maskContent = (sbyte)(1 << maskNumber);
/* --- format information --- */
sbyte formatInformationValue = (sbyte)(ec << 3 | maskNumber);
String[] formatInformationArray = new String[] { "101010000010010", "101000100100101", "101111001111100", "101101101001011", "100010111111001", "100000011001110", "100111110010111", "100101010100000", "111011111000100", "111001011110011", "111110110101010", "111100010011101", "110011000101111", "110001100011000", "110110001000001", "110100101110110", "001011010001001", "001001110111110", "001110011100111", "001100111010000", "000011101100010", "000001001010101", "000110100001100", "000100000111011", "011010101011111", "011000001101000", "011111100110001", "011101000000110", "010010010110100", "010000110000011", "010111011011010", "010101111101101" };
for (int i = 0; i < 15; i++)
{
sbyte content = (sbyte)System.SByte.Parse(formatInformationArray[formatInformationValue].Substring(i, (i + 1) - (i)));
matrixContent[formatInformationX1[i] & 0xFF][formatInformationY1[i] & 0xFF] = (sbyte)(content * 255);
matrixContent[formatInformationX2[i] & 0xFF][formatInformationY2[i] & 0xFF] = (sbyte)(content * 255);
}
bool[][] out_Renamed = new bool[modules1Side][];
for (int i3 = 0; i3 < modules1Side; i3++)
{
out_Renamed[i3] = new bool[modules1Side];
}
int c = 0;
for (int i = 0; i < modules1Side; i++)
{
for (int j = 0; j < modules1Side; j++)
{
if ((matrixContent[j][i] & maskContent) != 0 || frameData[c] == (char)49)
{
out_Renamed[j][i] = true;
}
else
{
out_Renamed[j][i] = false;
}
c++;
}
c++;
}
return(out_Renamed);
}
unsafe public static void Main()
{
// foo_1
{
Console.WriteLine("call native: foo_1");
foo_1();
Console.WriteLine("================================");
}
// foo_2
{
Console.WriteLine("call native: foo_2");
foo_2(123, "Hello World!");
Console.WriteLine("================================");
}
// foo_3
{
Console.WriteLine("call native: foo_3");
foo_3(new managed(){a=1,b=2,c=3});
Console.WriteLine("================================");
}
// foo_4
{
Console.WriteLine("call native: foo_4");
byte[] face = new byte[]
{
0x30,0x2e,0x30,
0x20,0x2d,0x20,
};
IntPtr dataPtr = Marshal.AllocHGlobal(32);
Marshal.Copy(face, 0, dataPtr, face.Length);
foo_4(dataPtr, face.Length);
Marshal.FreeHGlobal(dataPtr);
Console.WriteLine("================================");
}
// foo_5
{
Console.WriteLine("call native: foo_5");
IntPtr dataPtr;
int length = 0;
foo_5(out dataPtr, out length);
byte[] face = new byte[length];
Marshal.Copy(dataPtr, face, 0, length);
for (int i=0; i<2; ++i)
{
for (int j=0; j<3; ++j)
{
Console.Write((char)face[i*3+j]);
Console.Write(" ");
}
Console.Write("\n");
}
Console.WriteLine("================================");
}
// foo_6
{
Console.WriteLine("call native: foo_6");
IntPtr dataPtr;
int length = 0;
foo_6(out dataPtr, out length);
using (var stream = new UnmanagedMemoryStream((Byte*)dataPtr, length))
{
try
{
XmlDocument doc = new XmlDocument();
doc.Load(stream);
Console.WriteLine(doc.InnerXml);
}
catch (System.Exception e)
{
Console.WriteLine(e.Message);
}
}
Console.WriteLine("================================");
}
int count = 1000000000;
// empty
{
Console.WriteLine("call empty");
DateTime t0 = DateTime.Now;
for (int i=0; i<count; ++i)
{
}
DateTime t1 = DateTime.Now;
TimeSpan t = t1-t0;
Console.WriteLine("count: " + count + ", time: " + t.TotalMilliseconds + " ms.");
Console.WriteLine("================================");
}
// foo_7
{
Console.WriteLine("call native: foo_7");
DateTime t0 = DateTime.Now;
for (int i=0; i<count; ++i)
{
foo_7(i);
}
DateTime t1 = DateTime.Now;
TimeSpan t = t1-t0;
Console.WriteLine("count: " + count + ", time: " + t.TotalMilliseconds + " ms.");
Console.WriteLine("================================");
}
// foo_8
{
Console.WriteLine("call native: foo_8");
DateTime t0 = DateTime.Now;
for (int i=0; i<count; ++i)
{
foo_8("Hello World!");
}
DateTime t1 = DateTime.Now;
TimeSpan t = t1-t0;
Console.WriteLine("count: " + count + ", time: " + t.TotalMilliseconds + " ms.");
Console.WriteLine("================================");
}
// foo_9
{
Console.WriteLine("call native: foo_9");
DateTime t0 = DateTime.Now;
IntPtr dataPtr = Marshal.AllocHGlobal(32);
int length = 32;
for (int i=0; i<count; ++i)
{
foo_9(dataPtr, length);
}
DateTime t1 = DateTime.Now;
TimeSpan t = t1-t0;
Console.WriteLine("count: " + count + ", time: " + t.TotalMilliseconds + " ms.");
Console.WriteLine("================================");
}
// foo_10
{
Console.WriteLine("call native: foo_10");
DateTime t0 = DateTime.Now;
IntPtr dataPtr;
int length = 0;
for (int i=0; i<count; ++i)
{
foo_10(out dataPtr, out length);
}
DateTime t1 = DateTime.Now;
TimeSpan t = t1-t0;
Console.WriteLine("count: " + count + ", time: " + t.TotalMilliseconds + " ms.");
Console.WriteLine("================================");
}
}
public common(UnmanagedMemoryStream stream_, int offset_)
{
Data = stream_;
offset = offset_;
}
internal static void UmsInvariants(UnmanagedMemoryStream stream)
{
Assert.False(stream.CanTimeout);
}
public common(UnmanagedMemoryStream stream_)
{
Data = stream_;
offset = 0;
}
// internal for testing
internal static unsafe NativeHeapMemoryBlock DecodeEmbeddedPortablePdbDebugDirectoryData(AbstractMemoryBlock block)
{
NativeHeapMemoryBlock?decompressed;
var headerReader = block.GetReader();
if (headerReader.ReadUInt32() != PortablePdbVersions.DebugDirectoryEmbeddedSignature)
{
throw new BadImageFormatException(SR.UnexpectedEmbeddedPortablePdbDataSignature);
}
int decompressedSize = headerReader.ReadInt32();
try
{
decompressed = new NativeHeapMemoryBlock(decompressedSize);
}
catch
{
throw new BadImageFormatException(SR.DataTooBig);
}
bool success = false;
try
{
var compressed = new ReadOnlyUnmanagedMemoryStream(headerReader.CurrentPointer, headerReader.RemainingBytes);
var deflate = new DeflateStream(compressed, CompressionMode.Decompress, leaveOpen: true);
if (decompressedSize > 0)
{
int actualLength;
try
{
#if NETCOREAPP
actualLength = deflate.TryReadAll(new Span <byte>(decompressed.Pointer, decompressed.Size));
#else
using var decompressedStream = new UnmanagedMemoryStream(decompressed.Pointer, decompressed.Size, decompressed.Size, FileAccess.Write);
deflate.CopyTo(decompressedStream);
actualLength = (int)decompressedStream.Position;
#endif
}
catch (Exception e)
{
throw new BadImageFormatException(e.Message, e.InnerException);
}
if (actualLength != decompressed.Size)
{
throw new BadImageFormatException(SR.SizeMismatch);
}
}
// Check that there is no more compressed data left,
// in case the decompressed size specified in the header is smaller
// than the actual decompressed size of the data.
if (deflate.ReadByte() != -1)
{
throw new BadImageFormatException(SR.SizeMismatch);
}
success = true;
}
finally
{
if (!success)
{
decompressed.Dispose();
}
}
return(decompressed);
}
protected override void Write(UnmanagedMemoryStream stream, byte[] array, int offset, int count) => stream.Write(new Span <byte>(array, offset, count));
public static unsafe void ReadFromBufferBackedStream()
{
const int length = 8192;
byte[] data = new byte[length];
using (HGlobalSafeBuffer buffer = new HGlobalSafeBuffer(length))
{
for (ulong i = 0; i < length; i++)
buffer.Write(i, (byte)i);
Action validateData = () => {
for (int i = 0; i < length; i++)
Assert.Equal((byte)i, data[i]);
};
using (var stream = new UnmanagedMemoryStream(buffer, 0, length, FileAccess.Read))
{
stream.Position = 0;
Assert.Equal(length, stream.Read(data, 0, length));
validateData();
Array.Clear(data, 0, data.Length);
stream.Position = 0;
Assert.Equal(length / 2, stream.Read(data, 0, length / 2));
Assert.Equal(length / 2, stream.Read(data, length / 2, length / 2));
validateData();
Array.Clear(data, 0, data.Length);
Assert.True(stream.ReadAsync(data, 0, data.Length, new CancellationToken(true)).IsCanceled);
stream.Position = 0;
Task<int> t = stream.ReadAsync(data, 0, length / 4);
Assert.True(t.Status == TaskStatus.RanToCompletion);
Assert.Equal(length / 4, t.Result);
t = stream.ReadAsync(data, length / 4, length / 4);
Assert.True(t.Status == TaskStatus.RanToCompletion);
Assert.Equal(length / 4, t.Result);
t = stream.ReadAsync(data, length / 2, length / 2);
Assert.True(t.Status == TaskStatus.RanToCompletion);
Assert.Equal(length / 2, t.Result);
validateData();
Array.Clear(data, 0, data.Length);
}
}
}
void SendEmbeddedResource(HttpContext context, out EmbeddedResource res, out Assembly assembly)
{
HttpRequest request = context.Request;
NameValueCollection queryString = request.QueryString;
// val is URL-encoded, which means every + has been replaced with ' ', we
// need to revert that or the base64 conversion will fail.
string d = queryString ["d"];
if (!String.IsNullOrEmpty(d))
{
d = d.Replace(' ', '+');
}
AssemblyEmbeddedResources entry;
res = DecryptAssemblyResource(d, out entry);
WebResourceAttribute wra = res != null ? res.Attribute : null;
if (wra == null)
{
throw new HttpException(404, "Resource not found");
}
if (entry.AssemblyName == "s")
{
assembly = currAsm;
}
else
{
assembly = Assembly.Load(entry.AssemblyName);
}
long atime;
if (HasCacheControl(request, queryString, out atime))
{
if (atime == File.GetLastWriteTimeUtc(assembly.Location).Ticks)
{
RespondWithNotModified(context);
return;
}
}
DateTime modified;
if (HasIfModifiedSince(request, out modified))
{
if (File.GetLastWriteTimeUtc(assembly.Location) <= modified)
{
RespondWithNotModified(context);
return;
}
}
HttpResponse response = context.Response;
response.ContentType = wra.ContentType;
DateTime utcnow = DateTime.UtcNow;
response.Headers.Add("Last-Modified", utcnow.ToString("r"));
response.ExpiresAbsolute = utcnow.AddYears(1);
response.CacheControl = "public";
Stream s = assembly.GetManifestResourceStream(res.Name);
if (s == null)
{
throw new HttpException(404, "Resource " + res.Name + " not found");
}
if (wra.PerformSubstitution)
{
using (StreamReader r = new StreamReader(s)) {
TextWriter w = response.Output;
new PerformSubstitutionHelper(assembly).PerformSubstitution(r, w);
}
}
else if (response.OutputStream is HttpResponseStream)
{
UnmanagedMemoryStream st = (UnmanagedMemoryStream)s;
HttpResponseStream hstream = (HttpResponseStream)response.OutputStream;
unsafe {
hstream.WritePtr(new IntPtr(st.PositionPointer), (int)st.Length);
}
}
else
{
byte [] buf = new byte [1024];
Stream output = response.OutputStream;
int c;
do
{
c = s.Read(buf, 0, 1024);
output.Write(buf, 0, c);
} while (c > 0);
}
}
public Sound(UnmanagedMemoryStream AudioClip, double Vol)
{
Player = new SoundPlayer(AudioClip);
Player.LoadAsync();
SetVolume(Vol);
}
public RuntimeResourceSet(UnmanagedMemoryStream stream) : base(stream)
{
}
public static void WriteSafeBuffer()
{
const int length = 1000;
using (var buffer = new TestSafeBuffer(length))
{
var stream = new UnmanagedMemoryStream(buffer, 0, (long)buffer.ByteLength, FileAccess.Write);
Assert.Equal(stream.Length, length);
var bytes = ArrayHelpers.CreateByteArray(length);
var copy = bytes.Copy();
stream.Write(copy, 0, length);
var memory = buffer.ToArray();
Assert.Equal(bytes, memory, ArrayHelpers.Comparer<byte>());
stream.Write(new byte[0], 0, 0);
}
}
public void StartGame(UnmanagedMemoryStream soundResId)
{
// retrieve .wav from resource file.
sp = new SoundPlayer(soundResId);
sp.Play();
}
