389 lines
13 KiB
C#
389 lines
13 KiB
C#
//-----------------------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//-----------------------------------------------------------------------------
|
|
namespace System.ServiceModel.Channels
|
|
{
|
|
using System;
|
|
using System.Text;
|
|
|
|
static class IntEncoder
|
|
{
|
|
public const int MaxEncodedSize = 5;
|
|
|
|
public static int Encode(int value, byte[] bytes, int offset)
|
|
{
|
|
int count = 1;
|
|
while ((value & 0xFFFFFF80) != 0)
|
|
{
|
|
bytes[offset++] = (byte)((value & 0x7F) | 0x80);
|
|
count++;
|
|
value >>= 7;
|
|
}
|
|
bytes[offset] = (byte)value;
|
|
return count;
|
|
}
|
|
|
|
public static int GetEncodedSize(int value)
|
|
{
|
|
if (value < 0)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", value,
|
|
SR.GetString(SR.ValueMustBeNonNegative)));
|
|
}
|
|
|
|
int count = 1;
|
|
while ((value & 0xFFFFFF80) != 0)
|
|
{
|
|
count++;
|
|
value >>= 7;
|
|
}
|
|
return count;
|
|
}
|
|
}
|
|
|
|
abstract class EncodedFramingRecord
|
|
{
|
|
byte[] encodedBytes;
|
|
|
|
protected EncodedFramingRecord(byte[] encodedBytes)
|
|
{
|
|
this.encodedBytes = encodedBytes;
|
|
}
|
|
|
|
internal EncodedFramingRecord(FramingRecordType recordType, string value)
|
|
{
|
|
int valueByteCount = Encoding.UTF8.GetByteCount(value);
|
|
int sizeByteCount = IntEncoder.GetEncodedSize(valueByteCount);
|
|
encodedBytes = DiagnosticUtility.Utility.AllocateByteArray(checked(1 + sizeByteCount + valueByteCount));
|
|
encodedBytes[0] = (byte)recordType;
|
|
int offset = 1;
|
|
offset += IntEncoder.Encode(valueByteCount, encodedBytes, offset);
|
|
Encoding.UTF8.GetBytes(value, 0, value.Length, encodedBytes, offset);
|
|
SetEncodedBytes(encodedBytes);
|
|
}
|
|
|
|
|
|
public byte[] EncodedBytes
|
|
{
|
|
get { return encodedBytes; }
|
|
}
|
|
|
|
protected void SetEncodedBytes(byte[] encodedBytes)
|
|
{
|
|
this.encodedBytes = encodedBytes;
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
return (encodedBytes[0] << 16) |
|
|
(encodedBytes[encodedBytes.Length / 2] << 8) |
|
|
encodedBytes[encodedBytes.Length - 1];
|
|
}
|
|
|
|
public override bool Equals(object o)
|
|
{
|
|
if (o is EncodedFramingRecord)
|
|
return Equals((EncodedFramingRecord)o);
|
|
return false;
|
|
}
|
|
|
|
public bool Equals(EncodedFramingRecord other)
|
|
{
|
|
if (other == null)
|
|
return false;
|
|
if (other == this)
|
|
return true;
|
|
byte[] otherBytes = other.encodedBytes;
|
|
if (this.encodedBytes.Length != otherBytes.Length)
|
|
return false;
|
|
|
|
for (int i = 0; i < encodedBytes.Length; i++)
|
|
{
|
|
if (encodedBytes[i] != otherBytes[i])
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
class EncodedContentType : EncodedFramingRecord
|
|
{
|
|
EncodedContentType(FramingEncodingType encodingType) :
|
|
base(new byte[] { (byte)FramingRecordType.KnownEncoding, (byte)encodingType })
|
|
{
|
|
}
|
|
|
|
EncodedContentType(string contentType)
|
|
: base(FramingRecordType.ExtensibleEncoding, contentType)
|
|
{
|
|
}
|
|
|
|
public static EncodedContentType Create(string contentType)
|
|
{
|
|
if (contentType == FramingEncodingString.BinarySession)
|
|
{
|
|
return new EncodedContentType(FramingEncodingType.BinarySession);
|
|
}
|
|
else if (contentType == FramingEncodingString.Binary)
|
|
{
|
|
return new EncodedContentType(FramingEncodingType.Binary);
|
|
}
|
|
else if (contentType == FramingEncodingString.Soap12Utf8)
|
|
{
|
|
return new EncodedContentType(FramingEncodingType.Soap12Utf8);
|
|
}
|
|
else if (contentType == FramingEncodingString.Soap11Utf8)
|
|
{
|
|
return new EncodedContentType(FramingEncodingType.Soap11Utf8);
|
|
}
|
|
else if (contentType == FramingEncodingString.Soap12Utf16)
|
|
{
|
|
return new EncodedContentType(FramingEncodingType.Soap12Utf16);
|
|
}
|
|
else if (contentType == FramingEncodingString.Soap11Utf16)
|
|
{
|
|
return new EncodedContentType(FramingEncodingType.Soap11Utf16);
|
|
}
|
|
else if (contentType == FramingEncodingString.Soap12Utf16FFFE)
|
|
{
|
|
return new EncodedContentType(FramingEncodingType.Soap12Utf16FFFE);
|
|
}
|
|
else if (contentType == FramingEncodingString.Soap11Utf16FFFE)
|
|
{
|
|
return new EncodedContentType(FramingEncodingType.Soap11Utf16FFFE);
|
|
}
|
|
else if (contentType == FramingEncodingString.MTOM)
|
|
{
|
|
return new EncodedContentType(FramingEncodingType.MTOM);
|
|
}
|
|
else
|
|
{
|
|
return new EncodedContentType(contentType);
|
|
}
|
|
}
|
|
}
|
|
|
|
class EncodedVia : EncodedFramingRecord
|
|
{
|
|
public EncodedVia(string via)
|
|
: base(FramingRecordType.Via, via)
|
|
{
|
|
}
|
|
}
|
|
|
|
class EncodedUpgrade : EncodedFramingRecord
|
|
{
|
|
public EncodedUpgrade(string contentType)
|
|
: base(FramingRecordType.UpgradeRequest, contentType)
|
|
{
|
|
}
|
|
}
|
|
|
|
class EncodedFault : EncodedFramingRecord
|
|
{
|
|
public EncodedFault(string fault)
|
|
: base(FramingRecordType.Fault, fault)
|
|
{
|
|
}
|
|
}
|
|
|
|
// used by SimplexEncoder/DuplexEncoder
|
|
abstract class SessionEncoder
|
|
{
|
|
public const int MaxMessageFrameSize = 1 + IntEncoder.MaxEncodedSize;
|
|
|
|
protected SessionEncoder() { }
|
|
|
|
public static byte[] PreambleEndBytes = new byte[] {
|
|
(byte)FramingRecordType.PreambleEnd
|
|
};
|
|
|
|
public static byte[] EndBytes = new byte[] {
|
|
(Byte)FramingRecordType.End
|
|
};
|
|
|
|
public static int CalcStartSize(EncodedVia via, EncodedContentType contentType)
|
|
{
|
|
return via.EncodedBytes.Length + contentType.EncodedBytes.Length;
|
|
}
|
|
|
|
public static void EncodeStart(byte[] buffer, int offset, EncodedVia via, EncodedContentType contentType)
|
|
{
|
|
Buffer.BlockCopy(via.EncodedBytes, 0, buffer, offset, via.EncodedBytes.Length);
|
|
Buffer.BlockCopy(contentType.EncodedBytes, 0, buffer, offset + via.EncodedBytes.Length, contentType.EncodedBytes.Length);
|
|
}
|
|
|
|
public static ArraySegment<byte> EncodeMessageFrame(ArraySegment<byte> messageFrame)
|
|
{
|
|
int spaceNeeded = 1 + IntEncoder.GetEncodedSize(messageFrame.Count);
|
|
int offset = messageFrame.Offset - spaceNeeded;
|
|
if (offset < 0)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("messageFrame.Offset",
|
|
messageFrame.Offset, SR.GetString(SR.SpaceNeededExceedsMessageFrameOffset, spaceNeeded)));
|
|
}
|
|
|
|
byte[] buffer = messageFrame.Array;
|
|
buffer[offset++] = (byte)FramingRecordType.SizedEnvelope;
|
|
IntEncoder.Encode(messageFrame.Count, buffer, offset);
|
|
return new ArraySegment<byte>(buffer, messageFrame.Offset - spaceNeeded, messageFrame.Count + spaceNeeded);
|
|
}
|
|
}
|
|
|
|
// used by ServerDuplexEncoder/ServerSimplexEncoder
|
|
abstract class ServerSessionEncoder : SessionEncoder
|
|
{
|
|
protected ServerSessionEncoder() { }
|
|
|
|
public static byte[] AckResponseBytes = new byte[] {
|
|
(byte)FramingRecordType.PreambleAck
|
|
};
|
|
public static byte[] UpgradeResponseBytes = new byte[] {
|
|
(byte)FramingRecordType.UpgradeResponse
|
|
};
|
|
}
|
|
|
|
// Pattern:
|
|
// ModeBytes,
|
|
// EncodeStart,
|
|
// EncodeUpgrade*,
|
|
// EncodeMessageFrame*,
|
|
// EndBytes
|
|
class ClientDuplexEncoder : SessionEncoder
|
|
{
|
|
ClientDuplexEncoder() { }
|
|
|
|
public static byte[] ModeBytes = new byte[] {
|
|
(byte)FramingRecordType.Version,
|
|
(byte)FramingVersion.Major,
|
|
(byte)FramingVersion.Minor,
|
|
(byte)FramingRecordType.Mode,
|
|
(byte)FramingMode.Duplex };
|
|
}
|
|
|
|
// Pattern:
|
|
// ModeBytes,
|
|
// EncodeStart,
|
|
// EncodeUpgrade*,
|
|
// EncodeMessageFrame*,
|
|
// EndBytes
|
|
class ClientSimplexEncoder : SessionEncoder
|
|
{
|
|
ClientSimplexEncoder() { }
|
|
|
|
public static byte[] ModeBytes = new byte[] {
|
|
(byte)FramingRecordType.Version,
|
|
(byte)FramingVersion.Major,
|
|
(byte)FramingVersion.Minor,
|
|
(byte)FramingRecordType.Mode,
|
|
(byte)FramingMode.Simplex };
|
|
}
|
|
|
|
// shared code for client and server
|
|
abstract class SingletonEncoder
|
|
{
|
|
protected SingletonEncoder()
|
|
{
|
|
}
|
|
|
|
public static byte[] EnvelopeStartBytes = new byte[] {
|
|
(byte)FramingRecordType.UnsizedEnvelope };
|
|
|
|
public static byte[] EnvelopeEndBytes = new byte[] {
|
|
(byte)0 };
|
|
|
|
public static byte[] EnvelopeEndFramingEndBytes = new byte[] {
|
|
(byte)0, (byte)FramingRecordType.End };
|
|
|
|
public static byte[] EndBytes = new byte[] {
|
|
(byte)FramingRecordType.End };
|
|
|
|
public static ArraySegment<byte> EncodeMessageFrame(ArraySegment<byte> messageFrame)
|
|
{
|
|
int spaceNeeded = IntEncoder.GetEncodedSize(messageFrame.Count);
|
|
int offset = messageFrame.Offset - spaceNeeded;
|
|
if (offset < 0)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("messageFrame.Offset",
|
|
messageFrame.Offset, SR.GetString(SR.SpaceNeededExceedsMessageFrameOffset, spaceNeeded)));
|
|
}
|
|
|
|
byte[] buffer = messageFrame.Array;
|
|
IntEncoder.Encode(messageFrame.Count, buffer, offset);
|
|
return new ArraySegment<byte>(buffer, offset, messageFrame.Count + spaceNeeded);
|
|
}
|
|
}
|
|
|
|
// Pattern:
|
|
// ModeBytes,
|
|
// EncodeStart,
|
|
// EncodeUpgrade*,
|
|
// EnvelopeStartBytes,
|
|
// streamed-message-bytes*
|
|
class ClientSingletonEncoder : SingletonEncoder
|
|
{
|
|
ClientSingletonEncoder() { }
|
|
|
|
|
|
public static byte[] PreambleEndBytes = new byte[] {
|
|
(byte)FramingRecordType.PreambleEnd
|
|
};
|
|
|
|
public static byte[] ModeBytes = new byte[] {
|
|
(byte)FramingRecordType.Version,
|
|
(byte)FramingVersion.Major,
|
|
(byte)FramingVersion.Minor,
|
|
(byte)FramingRecordType.Mode,
|
|
(byte)FramingMode.Singleton };
|
|
|
|
public static int CalcStartSize(EncodedVia via, EncodedContentType contentType)
|
|
{
|
|
return via.EncodedBytes.Length + contentType.EncodedBytes.Length;
|
|
}
|
|
|
|
public static void EncodeStart(byte[] buffer, int offset, EncodedVia via, EncodedContentType contentType)
|
|
{
|
|
Buffer.BlockCopy(via.EncodedBytes, 0, buffer, offset, via.EncodedBytes.Length);
|
|
Buffer.BlockCopy(contentType.EncodedBytes, 0, buffer, offset + via.EncodedBytes.Length, contentType.EncodedBytes.Length);
|
|
}
|
|
}
|
|
|
|
// Pattern:
|
|
// (UpgradeResponseBytes, upgrade-bytes)?,
|
|
class ServerSingletonEncoder : SingletonEncoder
|
|
{
|
|
ServerSingletonEncoder() { }
|
|
|
|
public static byte[] AckResponseBytes = new byte[] {
|
|
(byte)FramingRecordType.PreambleAck
|
|
};
|
|
|
|
public static byte[] UpgradeResponseBytes = new byte[] {
|
|
(byte)FramingRecordType.UpgradeResponse
|
|
};
|
|
}
|
|
|
|
static class ClientSingletonSizedEncoder
|
|
{
|
|
public static byte[] ModeBytes = new byte[] {
|
|
(byte)FramingRecordType.Version,
|
|
(byte)FramingVersion.Major,
|
|
(byte)FramingVersion.Minor,
|
|
(byte)FramingRecordType.Mode,
|
|
(byte)FramingMode.SingletonSized };
|
|
|
|
public static int CalcStartSize(EncodedVia via, EncodedContentType contentType)
|
|
{
|
|
return via.EncodedBytes.Length + contentType.EncodedBytes.Length;
|
|
}
|
|
|
|
public static void EncodeStart(byte[] buffer, int offset, EncodedVia via, EncodedContentType contentType)
|
|
{
|
|
Buffer.BlockCopy(via.EncodedBytes, 0, buffer, offset, via.EncodedBytes.Length);
|
|
Buffer.BlockCopy(contentType.EncodedBytes, 0, buffer, offset + via.EncodedBytes.Length, contentType.EncodedBytes.Length);
|
|
}
|
|
}
|
|
|
|
}
|