389 lines
14 KiB
C#
389 lines
14 KiB
C#
//----------------------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//----------------------------------------------------------------------------
|
|
namespace System.ServiceModel.MsmqIntegration
|
|
{
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Runtime.Serialization;
|
|
using System.Diagnostics;
|
|
using System;
|
|
using System.IO;
|
|
using System.Globalization;
|
|
|
|
class ActiveXSerializer
|
|
{
|
|
|
|
byte[] byteBuffer;
|
|
char[] charBuffer;
|
|
object bufferLock = new object();
|
|
|
|
TKind[] TakeLockedBuffer<TKind>(out bool lockHeld, int size)
|
|
{
|
|
lockHeld = false;
|
|
Monitor.Enter(this.bufferLock, ref lockHeld);
|
|
if (typeof(byte) == typeof(TKind))
|
|
{
|
|
if (null == this.byteBuffer || size > this.byteBuffer.Length)
|
|
this.byteBuffer = new byte[size];
|
|
return this.byteBuffer as TKind[];
|
|
}
|
|
else if (typeof(char) == typeof(TKind))
|
|
{
|
|
if (null == this.charBuffer || size > this.charBuffer.Length)
|
|
this.charBuffer = new char[size];
|
|
return this.charBuffer as TKind[];
|
|
}
|
|
else
|
|
return null;
|
|
}
|
|
|
|
void ReleaseLockedBuffer()
|
|
{
|
|
Monitor.Exit(this.bufferLock);
|
|
}
|
|
|
|
public object Deserialize(MemoryStream stream, int bodyType)
|
|
{
|
|
if (stream == null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("stream"));
|
|
|
|
VarEnum variantType = (VarEnum)bodyType;
|
|
|
|
byte[] bytes;
|
|
byte[] newBytes;
|
|
int size;
|
|
int count;
|
|
bool lockHeld;
|
|
|
|
switch (variantType)
|
|
{
|
|
case VarEnum.VT_LPSTR:
|
|
bytes = stream.ToArray();
|
|
size = bytes.Length;
|
|
|
|
lockHeld = false;
|
|
try
|
|
{
|
|
char[] buffer = TakeLockedBuffer<char>(out lockHeld, size);
|
|
System.Text.Encoding.ASCII.GetChars(bytes, 0, size, buffer, 0);
|
|
return new String(buffer, 0, size);
|
|
}
|
|
finally
|
|
{
|
|
if (lockHeld)
|
|
{
|
|
ReleaseLockedBuffer();
|
|
}
|
|
}
|
|
case VarEnum.VT_BSTR:
|
|
case VarEnum.VT_LPWSTR:
|
|
bytes = stream.ToArray();
|
|
size = bytes.Length / 2;
|
|
|
|
lockHeld = false;
|
|
try
|
|
{
|
|
char[] buffer = TakeLockedBuffer<char>(out lockHeld, size);
|
|
System.Text.Encoding.Unicode.GetChars(bytes, 0, size * 2, buffer, 0);
|
|
return new String(buffer, 0, size);
|
|
}
|
|
finally
|
|
{
|
|
if (lockHeld)
|
|
{
|
|
ReleaseLockedBuffer();
|
|
}
|
|
}
|
|
case VarEnum.VT_VECTOR | VarEnum.VT_UI1:
|
|
bytes = stream.ToArray();
|
|
newBytes = new byte[bytes.Length];
|
|
Array.Copy(bytes, newBytes, bytes.Length);
|
|
|
|
return newBytes;
|
|
|
|
case VarEnum.VT_BOOL:
|
|
bytes = new byte[1];
|
|
count = stream.Read(bytes, 0, 1);
|
|
|
|
if (count != 1)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(SR.GetString(SR.MsmqCannotDeserializeActiveXMessage)));
|
|
|
|
return (bytes[0] != 0);
|
|
|
|
case VarEnum.VT_CLSID:
|
|
bytes = new byte[16];
|
|
count = stream.Read(bytes, 0, 16);
|
|
|
|
if (count != 16)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(SR.GetString(SR.MsmqCannotDeserializeActiveXMessage)));
|
|
|
|
return new Guid(bytes);
|
|
|
|
case VarEnum.VT_CY:
|
|
|
|
bytes = new byte[8];
|
|
count = stream.Read(bytes, 0, 8);
|
|
|
|
if (count != 8)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(SR.GetString(SR.MsmqCannotDeserializeActiveXMessage)));
|
|
|
|
return Decimal.FromOACurrency(BitConverter.ToInt64(bytes, 0));
|
|
|
|
case VarEnum.VT_DATE:
|
|
|
|
bytes = new byte[8];
|
|
count = stream.Read(bytes, 0, 8);
|
|
|
|
if (count != 8)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(SR.GetString(SR.MsmqCannotDeserializeActiveXMessage)));
|
|
|
|
return new DateTime(BitConverter.ToInt64(bytes, 0));
|
|
|
|
case VarEnum.VT_I1:
|
|
case VarEnum.VT_UI1:
|
|
|
|
bytes = new byte[1];
|
|
count = stream.Read(bytes, 0, 1);
|
|
|
|
if (count != 1)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(SR.GetString(SR.MsmqCannotDeserializeActiveXMessage)));
|
|
|
|
return bytes[0];
|
|
|
|
case VarEnum.VT_I2:
|
|
bytes = new byte[2];
|
|
count = stream.Read(bytes, 0, 2);
|
|
|
|
if (count != 2)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(SR.GetString(SR.MsmqCannotDeserializeActiveXMessage)));
|
|
|
|
return BitConverter.ToInt16(bytes, 0);
|
|
|
|
case VarEnum.VT_UI2:
|
|
bytes = new byte[2];
|
|
count = stream.Read(bytes, 0, 2);
|
|
|
|
if (count != 2)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(SR.GetString(SR.MsmqCannotDeserializeActiveXMessage)));
|
|
|
|
return BitConverter.ToUInt16(bytes, 0);
|
|
|
|
case VarEnum.VT_I4:
|
|
bytes = new byte[4];
|
|
count = stream.Read(bytes, 0, 4);
|
|
|
|
if (count != 4)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(SR.GetString(SR.MsmqCannotDeserializeActiveXMessage)));
|
|
|
|
return BitConverter.ToInt32(bytes, 0);
|
|
|
|
case VarEnum.VT_UI4:
|
|
bytes = new byte[4];
|
|
count = stream.Read(bytes, 0, 4);
|
|
|
|
if (count != 4)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(SR.GetString(SR.MsmqCannotDeserializeActiveXMessage)));
|
|
|
|
return BitConverter.ToUInt32(bytes, 0);
|
|
|
|
case VarEnum.VT_I8:
|
|
bytes = new byte[8];
|
|
count = stream.Read(bytes, 0, 8);
|
|
|
|
if (count != 8)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(SR.GetString(SR.MsmqCannotDeserializeActiveXMessage)));
|
|
|
|
return BitConverter.ToInt64(bytes, 0);
|
|
|
|
case VarEnum.VT_UI8:
|
|
bytes = new byte[8];
|
|
count = stream.Read(bytes, 0, 8);
|
|
|
|
if (count != 8)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(SR.GetString(SR.MsmqCannotDeserializeActiveXMessage)));
|
|
|
|
return BitConverter.ToUInt64(bytes, 0);
|
|
|
|
case VarEnum.VT_R4:
|
|
bytes = new byte[4];
|
|
count = stream.Read(bytes, 0, 4);
|
|
|
|
if (count != 4)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(SR.GetString(SR.MsmqCannotDeserializeActiveXMessage)));
|
|
|
|
return BitConverter.ToSingle(bytes, 0);
|
|
|
|
case VarEnum.VT_R8:
|
|
bytes = new byte[8];
|
|
count = stream.Read(bytes, 0, 8);
|
|
|
|
if (count != 8)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(SR.GetString(SR.MsmqCannotDeserializeActiveXMessage)));
|
|
|
|
return BitConverter.ToDouble(bytes, 0);
|
|
|
|
case VarEnum.VT_NULL:
|
|
return null;
|
|
|
|
|
|
default:
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(SR.GetString(SR.MsmqInvalidTypeDeserialization)));
|
|
}
|
|
}
|
|
|
|
|
|
public void Serialize(Stream stream, object obj, ref int bodyType)
|
|
{
|
|
if (stream == null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("stream"));
|
|
|
|
VarEnum variantType;
|
|
if (obj is string)
|
|
{
|
|
int size = ((string)obj).Length * 2;
|
|
|
|
bool lockHeld = false;
|
|
try
|
|
{
|
|
byte[] buffer = TakeLockedBuffer<byte>(out lockHeld, size);
|
|
System.Text.Encoding.Unicode.GetBytes(((string)obj).ToCharArray(), 0, size / 2, buffer, 0);
|
|
stream.Write(buffer, 0, size);
|
|
}
|
|
finally
|
|
{
|
|
if (lockHeld)
|
|
{
|
|
ReleaseLockedBuffer();
|
|
}
|
|
}
|
|
variantType = VarEnum.VT_LPWSTR;
|
|
}
|
|
else if (obj is byte[])
|
|
{
|
|
byte[] bytes = (byte[])obj;
|
|
stream.Write(bytes, 0, bytes.Length);
|
|
variantType = VarEnum.VT_UI1 | VarEnum.VT_VECTOR;
|
|
}
|
|
else if (obj is char[])
|
|
{
|
|
char[] chars = (char[])obj;
|
|
int size = chars.Length * 2;
|
|
|
|
bool lockHeld = false;
|
|
try
|
|
{
|
|
byte[] buffer = TakeLockedBuffer<byte>(out lockHeld, size);
|
|
System.Text.Encoding.Unicode.GetBytes(chars, 0, size / 2, buffer, 0);
|
|
stream.Write(buffer, 0, size);
|
|
}
|
|
finally
|
|
{
|
|
if (lockHeld)
|
|
{
|
|
ReleaseLockedBuffer();
|
|
}
|
|
}
|
|
variantType = VarEnum.VT_LPWSTR;
|
|
}
|
|
else if (obj is byte)
|
|
{
|
|
stream.Write(new byte[] { (byte)obj }, 0, 1);
|
|
variantType = VarEnum.VT_UI1;
|
|
}
|
|
else if (obj is bool)
|
|
{
|
|
if ((bool)obj)
|
|
stream.Write(new byte[] { 0xff }, 0, 1);
|
|
else
|
|
stream.Write(new byte[] { 0x00 }, 0, 1);
|
|
variantType = VarEnum.VT_BOOL;
|
|
}
|
|
else if (obj is char)
|
|
{
|
|
byte[] bytes = BitConverter.GetBytes((Char)obj);
|
|
stream.Write(bytes, 0, 2);
|
|
variantType = VarEnum.VT_UI2;
|
|
}
|
|
else if (obj is Decimal)
|
|
{
|
|
byte[] bytes = BitConverter.GetBytes(Decimal.ToOACurrency((Decimal)obj));
|
|
stream.Write(bytes, 0, 8);
|
|
variantType = VarEnum.VT_CY;
|
|
}
|
|
else if (obj is DateTime)
|
|
{
|
|
byte[] bytes = BitConverter.GetBytes(((DateTime)obj).Ticks);
|
|
stream.Write(bytes, 0, 8);
|
|
variantType = VarEnum.VT_DATE;
|
|
}
|
|
else if (obj is Double)
|
|
{
|
|
byte[] bytes = BitConverter.GetBytes((Double)obj);
|
|
stream.Write(bytes, 0, 8);
|
|
variantType = VarEnum.VT_R8;
|
|
}
|
|
else if (obj is Guid)
|
|
{
|
|
byte[] bytes = ((Guid)obj).ToByteArray();
|
|
stream.Write(bytes, 0, 16);
|
|
variantType = VarEnum.VT_CLSID;
|
|
}
|
|
else if (obj is Int16)
|
|
{
|
|
byte[] bytes = BitConverter.GetBytes((short)obj);
|
|
stream.Write(bytes, 0, 2);
|
|
variantType = VarEnum.VT_I2;
|
|
}
|
|
else if (obj is UInt16)
|
|
{
|
|
byte[] bytes = BitConverter.GetBytes((UInt16)obj);
|
|
stream.Write(bytes, 0, 2);
|
|
variantType = VarEnum.VT_UI2;
|
|
}
|
|
else if (obj is Int32)
|
|
{
|
|
byte[] bytes = BitConverter.GetBytes((int)obj);
|
|
stream.Write(bytes, 0, 4);
|
|
variantType = VarEnum.VT_I4;
|
|
}
|
|
else if (obj is UInt32)
|
|
{
|
|
|
|
byte[] bytes = BitConverter.GetBytes((UInt32)obj);
|
|
stream.Write(bytes, 0, 4);
|
|
variantType = VarEnum.VT_UI4;
|
|
}
|
|
else if (obj is Int64)
|
|
{
|
|
|
|
byte[] bytes = BitConverter.GetBytes((Int64)obj);
|
|
stream.Write(bytes, 0, 8);
|
|
variantType = VarEnum.VT_I8;
|
|
}
|
|
else if (obj is UInt64)
|
|
{
|
|
|
|
byte[] bytes = BitConverter.GetBytes((UInt64)obj);
|
|
stream.Write(bytes, 0, 8);
|
|
variantType = VarEnum.VT_UI8;
|
|
}
|
|
else if (obj is Single)
|
|
{
|
|
|
|
byte[] bytes = BitConverter.GetBytes((float)obj);
|
|
stream.Write(bytes, 0, 4);
|
|
variantType = VarEnum.VT_R4;
|
|
}
|
|
else
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.MsmqInvalidTypeSerialization)));
|
|
}
|
|
|
|
bodyType = (int)variantType;
|
|
}
|
|
|
|
}
|
|
}
|