public override int ReadContentAsBase64(byte[] buffer, int index, int count)
{
int readCount = innerReader.ReadContentAsBase64(buffer, index, count);
if (readCount == 0)
{
//GetReaderFromNextChunk will wait for chunks to be queued
//then set this.innerReader to the received message's reader
//it will throw TimeoutException if the next chunk is not received within specified timeout
GetReaderFromNextChunk(receiveTimeout);
if (!isLastChunk)
{
readCount = innerReader.ReadContentAsBase64(buffer,
index, count);
if (readCount == 0)
{
throw new CommunicationException(
"Received chunk contains no data");
}
else
{
return(readCount);
}
}
else //lastChunk
{
return(0);
}
}
else
{
return(readCount);
}
}
private string SelectOperationInternal(Message message)
{
byte[] rawBody;
using (XmlDictionaryReader bodyReader = message.GetReaderAtBodyContents()) {
bodyReader.ReadStartElement("Binary");
rawBody = bodyReader.ReadContentAsBase64();
}
string operation = null;
using (var bodyReader = new JsonTextReader(new StreamReader(new MemoryStream(rawBody)))) {
while (bodyReader.Read())
{
if (bodyReader.TokenType == JsonToken.PropertyName)
{
string propertyName = (string)bodyReader.Value;
if (propertyName.Equals("method", StringComparison.Ordinal))
{
if (!bodyReader.Read() || bodyReader.TokenType != JsonToken.String)
{
throw new InvalidOperationException("Invalid message format.");
}
operation = (string)bodyReader.Value;
break;
}
}
}
}
return(operation);
}
public void ReadXml(XmlDictionaryReader reader)
{
if (reader == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("reader");
}
reader.MoveToContent();
if (!reader.IsStartElement(XmlEncryptionConstants.Elements.CipherData, XmlEncryptionConstants.Namespace))
{
throw DiagnosticUtility.ThrowHelperXml(reader, SR.GetString(SR.ID4188));
}
reader.ReadStartElement(XmlEncryptionConstants.Elements.CipherData, XmlEncryptionConstants.Namespace);
reader.ReadStartElement(XmlEncryptionConstants.Elements.CipherValue, XmlEncryptionConstants.Namespace);
_cipherText = reader.ReadContentAsBase64();
_iv = null;
// <CipherValue>
reader.MoveToContent();
reader.ReadEndElement();
// <CipherData>
reader.MoveToContent();
reader.ReadEndElement();
}
private string RawMessageToString(ref Message message)
{
XmlDictionaryReader bodyReader = message.GetReaderAtBodyContents();
bodyReader.ReadStartElement("Binary");
byte[] requestBody = bodyReader.ReadContentAsBase64();
string messageAsString = Encoding.UTF8.GetString(requestBody);
MemoryStream ms = new MemoryStream();
XmlDictionaryWriter writer = XmlDictionaryWriter.CreateBinaryWriter(ms);
writer.WriteStartElement("Binary");
writer.WriteBase64(requestBody, 0, requestBody.Length);
writer.WriteEndElement();
writer.Flush();
ms.Position = 0;
XmlDictionaryReader reader = XmlDictionaryReader.CreateBinaryReader(ms, XmlDictionaryReaderQuotas.Max);
Message newMessage = Message.CreateMessage(reader, int.MaxValue, message.Version);
newMessage.Properties.CopyProperties(message.Properties);
message = newMessage;
return(messageAsString);
}
public object DeserializeReply(Message message, object[] parameters)
{
object bodyFormatProperty;
if (!message.Properties.TryGetValue(WebBodyFormatMessageProperty.Name, out bodyFormatProperty) ||
(bodyFormatProperty as WebBodyFormatMessageProperty).Format != WebContentFormat.Raw)
{
throw new InvalidOperationException("Incoming messages must have a body format of Raw. Is a ContentTypeMapper set on the WebHttpBinding?");
}
XmlDictionaryReader bodyReader = message.GetReaderAtBodyContents();
Newtonsoft.Json.JsonSerializer serializer = endpoint.NewtonsoftSettings().JsonSerializer;
bodyReader.ReadStartElement("Binary");
byte[] body = bodyReader.ReadContentAsBase64();
try {
using (MemoryStream ms = new MemoryStream(body)) {
using (StreamReader sr = new StreamReader(ms)) {
Type returnType = this.operation.Messages[1].Body.ReturnValue.Type;
var result = serializer.Deserialize(sr, returnType);
if (traceSource.Switch.ShouldTrace(TraceEventType.Information))
{
traceSource.TraceEvent(TraceEventType.Information, 1004, System.Text.Encoding.UTF8.GetString(body));
}
return(result);
}
}
} catch {
traceSource.TraceEvent(TraceEventType.Error, 1005, System.Text.Encoding.UTF8.GetString(body));
throw;
}
}
private string ReadRawBody(ref Message message)
{
XmlDictionaryReader bodyReader = message.GetReaderAtBodyContents();
bodyReader.ReadStartElement("Binary");
byte[] bodyBytes = bodyReader.ReadContentAsBase64();
//MemoryStream ms1 = new MemoryStream(bodyBytes);
//StreamReader sr = new StreamReader(ms1);
//JsonSerializer serializer = JsonHelper.GetJsonSerializer();
//var obj = serializer.Deserialize(sr, typeof(ReturnMessage<object>));
string messageBody = Encoding.UTF8.GetString(bodyBytes);
// Now to recreate the message
MemoryStream ms = new MemoryStream();
XmlDictionaryWriter writer = XmlDictionaryWriter.CreateBinaryWriter(ms);
writer.WriteStartElement("Binary");
writer.WriteBase64(bodyBytes, 0, bodyBytes.Length);
writer.WriteEndElement();
writer.Flush();
ms.Position = 0;
XmlDictionaryReader reader = XmlDictionaryReader.CreateBinaryReader(ms, XmlDictionaryReaderQuotas.Max);
Message newMessage = Message.CreateMessage(reader, int.MaxValue, message.Version);
newMessage.Properties.CopyProperties(message.Properties);
newMessage.Headers.CopyHeadersFrom(message);
message = newMessage;
return(messageBody);
}
public void DeserializeRequest(Message message, object[] parameters)
{
if (IsFormUrlEncodedMessage(message))
{
XmlDictionaryReader bodyReader = message.GetReaderAtBodyContents();
bodyReader.ReadStartElement("Binary");
byte[] bodyBytes = bodyReader.ReadContentAsBase64();
string body = Encoding.UTF8.GetString(bodyBytes);
NameValueCollection pairs = HttpUtility.ParseQueryString(body);
Dictionary <string, string> values = new Dictionary <string, string>();
foreach (var key in pairs.AllKeys)
{
values.Add(key, pairs[key]);
}
foreach (var part in this.operation.Messages[0].Body.Parts)
{
if (values.ContainsKey(part.Name))
{
string value = values[part.Name];
parameters[part.Index] = this.queryStringConverter.ConvertStringToValue(value, part.Type);
}
else
{
parameters[part.Index] = GetDefaultValue(part.Type);
}
}
}
else
{
this.originalFormatter.DeserializeRequest(message, parameters);
}
}
public void BeforeSendReply(ref System.ServiceModel.Channels.Message reply, object correlationState)
{
if (correlationState != null && correlationState is string)
{
// if we have a $metadata response then buffer the response
// and merge it with the updated items
if (mdataresponse == string.Empty)
{
XmlDictionaryReader reader = reply.GetReaderAtBodyContents();
reader.ReadStartElement();
string content = MetadataInspector.encoding.GetString(reader.ReadContentAsBase64());
string filename = ((string)correlationState).Replace(@"/$", ".").Substring(1) + ".xml";
string fullpath = AppDomain.CurrentDomain.BaseDirectory + filename;
File.WriteAllText(fullpath, content);
mdataresponse = content;
//mdataresponse = MetadataConverter.Convert(content);
}
Message newreply = Message.CreateMessage(MessageVersion.None, "", new Writer(mdataresponse));
newreply.Properties.CopyProperties(reply.Properties);
reply = newreply;
}
}
/// <summary>
///
/// </summary>
/// <param name="message"></param>
/// <param name="parameters"></param>
public void DeserializeRequest(Message message, object[] parameters)
{
object bodyFormatProperty;
if (!message.Properties.TryGetValue(WebBodyFormatMessageProperty.Name, out bodyFormatProperty))
{
throw new InvalidOperationException("Incoming message cannot be null.");
}
WebBodyFormatMessageProperty bodyMsg = bodyFormatProperty as WebBodyFormatMessageProperty;
if (bodyMsg == null)
{
throw new InvalidCastException("The type of body message must be WebBodyFormatMessageProperty.");
}
if (bodyMsg.Format != WebContentFormat.Raw)
{
throw new InvalidOperationException("The body message type must be equals to WebContentFormat.Raw.");
}
////
XmlDictionaryReader bodyReader = message.GetReaderAtBodyContents();
bodyReader.ReadStartElement(BinaryRawBodyWriter.DefaultRootName);
this.DecodeParameters(bodyReader.ReadContentAsBase64(), parameters);
}
/// <summary>
/// Extracts the message body as a string
/// </summary>
/// <param name="msg">The message from which the body will be extracted</param>
/// <param name="encoding">The encoding in which the body is expected to be</param>
/// <returns>The message body in string representation</returns>
public static string GetBodyAsString(Message msg, Encoding encoding)
{
XmlDictionaryReader xdr = msg.GetReaderAtBodyContents();
xdr.ReadStartElement("MessageContent");
return(encoding.GetString(xdr.ReadContentAsBase64()));
}
/// <summary>
/// Reads a serialized token and converts it into a <see cref="SecurityToken"/>.
/// </summary>
/// <param name="reader">An XML reader positioned at the token's start element.</param>
/// <returns>The parsed form of the token.</returns>
public override SecurityToken ReadToken(XmlReader reader)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
XmlDictionaryReader dictionaryReader = XmlDictionaryReader.CreateDictionaryReader(reader);
byte[] binaryData;
string encoding = dictionaryReader.GetAttribute(EncodingType);
if (encoding == null || encoding == Base64EncodingType)
{
dictionaryReader.Read();
binaryData = dictionaryReader.ReadContentAsBase64();
}
else
{
throw new SecurityTokenException(
"Cannot read SecurityToken as its encoding is" + encoding + ". Expected a BinarySecurityToken with base64 encoding.");
}
string serializedToken = Encoding.UTF8.GetString(binaryData);
return(ReadSecurityTokenFromString(serializedToken));
}
public override SecurityKeyIdentifierClause ReadClause(XmlDictionaryReader reader, byte[] derivationNonce, int derivationLength, string tokenType)
{
string encodingType = reader.GetAttribute(XD.SecurityJan2004Dictionary.EncodingType, null);
if (encodingType == null)
{
encodingType = DefaultEncodingType;
}
reader.ReadStartElement();
byte[] bytes;
if (encodingType == EncodingTypeValueBase64Binary)
{
bytes = reader.ReadContentAsBase64();
}
else if (encodingType == EncodingTypeValueHexBinary)
{
bytes = HexBinary.Parse(reader.ReadContentAsString()).Value;
}
else if (encodingType == EncodingTypeValueText)
{
bytes = new UTF8Encoding().GetBytes(reader.ReadContentAsString());
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityMessageSerializationException(SR.GetString(SR.UnknownEncodingInKeyIdentifier)));
}
reader.ReadEndElement();
return(CreateClause(bytes, derivationNonce, derivationLength));
}
public static byte[] DeserializeBody(Message message)
{
using (XmlDictionaryReader bodyReader = message.GetReaderAtBodyContents()) {
bodyReader.ReadStartElement("Binary");
return(bodyReader.ReadContentAsBase64());
}
}
public static JObject DeserializeMessage(Message message)
{
if (message.Properties.ContainsKey(JsonRpcConstants.JObjectMessageProperty))
{
return((JObject)message.Properties[JsonRpcConstants.JObjectMessageProperty]);
}
else
{
JObject json = null;
byte[] bytes = null;
using (XmlDictionaryReader bodyReader = message.GetReaderAtBodyContents())
{
bodyReader.ReadStartElement("Binary");
bytes = bodyReader.ReadContentAsBase64();
}
using (MemoryStream ms = new MemoryStream(bytes))
{
using (StreamReader sr = new StreamReader(ms))
{
using (JsonTextReader jtr = new JsonTextReader(sr))
{
json = JObject.Load(jtr);
}
}
}
if (json == null)
{
throw new ArgumentException("Message must be a JSON object");
}
return(json);
}
}
internal static byte[] ReadContentAsBase64(XmlDictionaryReader reader, long maxBufferSize)
{
if (reader == null)
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("reader");
}
byte[][] numArray1 = new byte[32][];
int length1 = 384;
int num1 = 0;
int length2 = 0;
while (true)
{
byte[] buffer = new byte[length1];
numArray1[num1++] = buffer;
int index = 0;
while (index < buffer.Length)
{
int num2 = reader.ReadContentAsBase64(buffer, index, buffer.Length - index);
if (num2 != 0)
{
index += num2;
}
else
{
break;
}
}
if ((long)length2 <= maxBufferSize - (long)index)
{
length2 += index;
if (index >= buffer.Length)
{
length1 *= 2;
}
else
{
goto label_11;
}
}
else
{
break;
}
}
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError((Exception) new QuotaExceededException(SR.GetString("BufferQuotaExceededReadingBase64", new object[1] {
(object)maxBufferSize
})));
label_11:
byte[] numArray2 = new byte[length2];
int dstOffset = 0;
for (int index = 0; index < num1 - 1; ++index)
{
Buffer.BlockCopy((Array)numArray1[index], 0, (Array)numArray2, dstOffset, numArray1[index].Length);
dstOffset += numArray1[index].Length;
}
Buffer.BlockCopy((Array)numArray1[num1 - 1], 0, (Array)numArray2, dstOffset, length2 - dstOffset);
return(numArray2);
}
private static string MessageContentAsString(Message msg, AmqpProperties props)
{
// AmqpBinaryBinding provides message content as a single XML "Binary" element
XmlDictionaryReader reader = msg.GetReaderAtBodyContents();
while (!reader.HasValue)
{
reader.Read();
if (reader.EOF)
{
throw new InvalidDataException("empty reader for message");
}
}
byte[] rawdata = reader.ReadContentAsBase64();
string ct = props.ContentType;
if (ct != null)
{
if (ct.Equals("amqp/map"))
{
return("mapdata (coming soon)");
}
}
return(Encoding.UTF8.GetString(rawdata));
}
/// <summary>
/// Enables inspection or modification of a message after a reply message is received but prior to passing it back to the client application.
/// </summary>
/// <param name="reply">The message to be transformed into types and handed back to the client application.</param>
/// <param name="correlationState">Correlation state data.</param>
public void AfterReceiveReply(ref System.ServiceModel.Channels.Message reply, object correlationState)
{
HttpResponseMessageProperty property = null;
if (reply.Properties.ContainsKey(HttpResponseMessageProperty.Name))
{
property = (reply.Properties[HttpResponseMessageProperty.Name] as HttpResponseMessageProperty);
}
if (property != null)
{
var errorStatus = property.Headers[NewtonsoftJsonErrorHandler.ClientHeader];
if (errorStatus != null)
{
XmlDictionaryReader bodyReader = reply.GetReaderAtBodyContents();
Newtonsoft.Json.JsonSerializer serializer = endpoint.NewtonsoftSettings().JsonSerializer;
bodyReader.ReadStartElement("Binary");
byte[] body = bodyReader.ReadContentAsBase64();
using (MemoryStream ms = new MemoryStream(body)) {
using (StreamReader sr = new StreamReader(ms)) {
var result = (CommonFault)serializer.Deserialize(sr, typeof(CommonFault));
throw new FaultException <CommonFault>(result, result.Error);
}
}
}
}
}
public static string ReadRawBody(ref Message message)
{
XmlDictionaryReader bodyReader = message.GetReaderAtBodyContents();
bodyReader.ReadStartElement("Binary");
byte[] bodyBytes = bodyReader.ReadContentAsBase64();
string messageBody = Encoding.UTF8.GetString(bodyBytes);
// Now to recreate the message
MemoryStream ms = new MemoryStream();
XmlDictionaryWriter writer = XmlDictionaryWriter.CreateBinaryWriter(ms);
writer.WriteStartElement("Binary");
writer.WriteBase64(bodyBytes, 0, bodyBytes.Length);
writer.WriteEndElement();
writer.Flush();
ms.Position = 0;
XmlDictionaryReader reader = XmlDictionaryReader.CreateBinaryReader(ms, XmlDictionaryReaderQuotas.Max);
Message newMessage = Message.CreateMessage(reader, int.MaxValue, message.Version);
newMessage.Properties.CopyProperties(message.Properties);
message = newMessage;
return(messageBody);
}
public void BeforeSendReply(ref System.ServiceModel.Channels.Message reply, object correlationState)
{
if (reply == null)
{
throw new ArgumentNullException("reply");
}
if (correlationState != null && correlationState is string)
{
// if we have a JSONP callback then buffer the response, wrap it with the callback call and then re-create the response message
string callback = (string)correlationState;
XmlDictionaryReader reader = reply.GetReaderAtBodyContents();
reader.ReadStartElement();
string content = JSONPSupportInspector.encoding.GetString(reader.ReadContentAsBase64());
content = callback + "(" + content + ");";
using (Message newreply = Message.CreateMessage(MessageVersion.None, "", new Writer(content)))
{
newreply.Properties.CopyProperties(reply.Properties);
reply = newreply;
// change response content type to text/javascript if the JSON (only done when wrapped in a callback)
var replyProperties = (HttpResponseMessageProperty)reply.Properties[HttpResponseMessageProperty.Name];
replyProperties.Headers["Content-Type"] = replyProperties.Headers["Content-Type"].Replace("application/json", "text/javascript");
}
}
}
/// <summary>
/// Reads the raw body.
/// </summary>
/// <param name="message">The message.</param>
/// <returns></returns>
private string ReadRawBody(Message message)
{
XmlDictionaryReader bodyReader = message.GetReaderAtBodyContents();
bodyReader.ReadStartElement("Binary");
return(Encoding.UTF8.GetString(bodyReader.ReadContentAsBase64()));
}
public override object ReadObject(XmlDictionaryReader reader, bool verifyObjectName)
{
reader.ReadStartElement("Data");
var data = reader.ReadContentAsBase64();
reader.ReadEndElement();
return(DecodeObject(data));
}
/// <summary>
/// Extracts the message body as a string
/// </summary>
/// <param name="msg">The message from which the body will be extracted</param>
/// <returns>The bytes of the message body</returns>
public static byte[] GetBodyAsBytes(Message msg)
{
XmlDictionaryReader xdr = msg.GetReaderAtBodyContents();
xdr.ReadStartElement("MessageContent");
return(xdr.ReadContentAsBase64());
}
public void DeserializeRequest(Message message, object[] parameters)
{
object bodyFormatProperty;
if (!message.Properties.TryGetValue(WebBodyFormatMessageProperty.Name, out bodyFormatProperty) ||
(bodyFormatProperty as WebBodyFormatMessageProperty).Format != WebContentFormat.Raw)
{
throw new InvalidOperationException("Incoming messages must have a body format of Raw. Is a ContentTypeMapper set on the WebHttpBinding?");
}
XmlDictionaryReader bodyReader = message.GetReaderAtBodyContents();
bodyReader.ReadStartElement("Binary");
byte[] rawBody = bodyReader.ReadContentAsBase64();
MemoryStream ms = new MemoryStream(rawBody);
StreamReader sr = new StreamReader(ms);
Newtonsoft.Json.JsonSerializer serializer = new Newtonsoft.Json.JsonSerializer();
if (parameters.Length == 1)
{
// single parameter, assuming bare
parameters[0] = serializer.Deserialize(sr, operation.Messages[0].Body.Parts[0].Type);
}
else
{
// multiple parameter, needs to be wrapped
Newtonsoft.Json.JsonReader reader = new Newtonsoft.Json.JsonTextReader(sr);
reader.Read();
if (reader.TokenType != Newtonsoft.Json.JsonToken.StartObject)
{
throw new InvalidOperationException("Input needs to be wrapped in an object");
}
reader.Read();
while (reader.TokenType == Newtonsoft.Json.JsonToken.PropertyName)
{
string parameterName = reader.Value as string;
reader.Read();
if (this.parameterNames.ContainsKey(parameterName))
{
int parameterIndex = this.parameterNames[parameterName];
parameters[parameterIndex] = serializer.Deserialize(reader, this.operation.Messages[0].Body.Parts[parameterIndex].Type);
}
else
{
reader.Skip();
}
reader.Read();
}
reader.Close();
}
sr.Close();
ms.Close();
}
private MockMessage PrepareMockMessage(System.ServiceModel.Channels.Message message)
{
byte[] msgBuffer = null;
if (!message.IsFault)
{
// Handling regular content messages
System.Diagnostics.Debug.WriteLine(
"Handling content response message",
"TransMock.Wcf.Adapter.MockAdapterInboundReply");
XmlDictionaryReader xdr = message.GetReaderAtBodyContents();
// Read the start element and extract its contents as a base64 encoded bytes
if (xdr.NodeType == XmlNodeType.Element)
{
// in case the content is nested in an element under the Body element
xdr.Read();
}
msgBuffer = xdr.ReadContentAsBase64();
}
else
{
// Handling faults returned by BizTalk
System.Diagnostics.Debug.WriteLine(
"Handling fault response message",
"TransMock.Wcf.Adapter.MockAdapterInboundReply");
using (var messageBuffer = message.CreateBufferedCopy(1024 ^ 3)) // Allowing for buffer of 1 GB
{
using (var msgStream = new System.IO.MemoryStream(4096))
{
messageBuffer.WriteMessage(msgStream);
msgBuffer = Convert.FromBase64String(
Convert.ToBase64String(msgStream.ToArray()));
}
}
}
if (msgBuffer.Length == 0)
{
// Message is with empty body, simply return
System.Diagnostics.Debug.WriteLine(
"Response message has empty body. Exiting.",
"TransMock.Wcf.Adapter.MockAdapterInboundReply");
return(null);
}
// Create MockMessage intance
var mockMessage = new MockMessage(
msgBuffer,
this.encoding);
return(mockMessage);
}
public static ClaimSet DeserializeClaimSet(XmlDictionaryReader reader, SctClaimDictionary dictionary, XmlObjectSerializer serializer, XmlObjectSerializer claimSerializer)
{
if (reader.IsStartElement(dictionary.NullValue, dictionary.EmptyString))
{
reader.ReadElementString();
return(null);
}
else if (reader.IsStartElement(dictionary.X509CertificateClaimSet, dictionary.EmptyString))
{
reader.ReadStartElement();
byte[] rawData = reader.ReadContentAsBase64();
reader.ReadEndElement();
return(new X509CertificateClaimSet(new X509Certificate2(rawData), false));
}
else if (reader.IsStartElement(dictionary.SystemClaimSet, dictionary.EmptyString))
{
reader.ReadElementString();
return(ClaimSet.System);
}
else if (reader.IsStartElement(dictionary.WindowsClaimSet, dictionary.EmptyString))
{
reader.ReadElementString();
return(ClaimSet.Windows);
}
else if (reader.IsStartElement(dictionary.AnonymousClaimSet, dictionary.EmptyString))
{
reader.ReadElementString();
return(ClaimSet.Anonymous);
}
else if (reader.IsStartElement(dictionary.ClaimSet, dictionary.EmptyString))
{
ClaimSet issuer = null;
List <Claim> claims = new List <Claim>();
reader.ReadStartElement();
if (reader.IsStartElement(dictionary.PrimaryIssuer, dictionary.EmptyString))
{
reader.ReadStartElement();
issuer = DeserializeClaimSet(reader, dictionary, serializer, claimSerializer);
reader.ReadEndElement();
}
while (reader.IsStartElement())
{
reader.ReadStartElement();
claims.Add(DeserializeClaim(reader, dictionary, claimSerializer));
reader.ReadEndElement();
}
reader.ReadEndElement();
return(issuer != null ? new DefaultClaimSet(issuer, claims) : new DefaultClaimSet(claims));
}
else
{
return((ClaimSet)serializer.ReadObject(reader));
}
}
// This is the method to action after receiving a response from Sabre
public void AfterReceiveReply(ref Message reply, object correlationState)
{
try
{
// Get compressed response from reply and load that into a byte array.
XmlDictionaryReader bodyReader = reply.GetReaderAtBodyContents();
bodyReader.ReadStartElement("CompressedResponse");
byte[] bodyByteArray = bodyReader.ReadContentAsBase64();
// Create some helper variables
StringBuilder uncompressed = new StringBuilder();
String xmlString = "";
XmlDocument xmlPayload = new XmlDocument();
// Load the byte array into memory
using (MemoryStream memoryStream = new MemoryStream(bodyByteArray))
{
// Unzip the Stream
using (GZipStream gZipStream = new GZipStream(memoryStream, CompressionMode.Decompress))
{
byte[] buffer = new byte[1024];
int readBytes;
// Unzips character by character
while ((readBytes = gZipStream.Read(buffer, 0, buffer.Length)) != 0)
{
for (int i = 0; i < readBytes; i++)
{
// Append all characters to build the response
uncompressed.Append((char)buffer[i]);
}
}
}
xmlString = uncompressed.ToString();
xmlString = xmlString.Replace("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>", "");
}
// Convert the string into an XML
xmlPayload.LoadXml(xmlString);
// Create a new Message, which is what will substitute what was returned by Sabre
Message tempMessage = Message.CreateMessage(reply.Version, null, xmlPayload.ChildNodes[0]);
tempMessage.Headers.CopyHeadersFrom(reply.Headers);
tempMessage.Properties.CopyProperties(reply.Properties);
MessageBuffer bufferOfFault = tempMessage.CreateBufferedCopy(Int32.MaxValue);
// Replace the reply with the new Message
reply = bufferOfFault.CreateMessage();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public void BeforeSendReply(ref Message reply, object correlationState)
{
if (correlationState != null)
{
MessageInfo messageInfo = correlationState as MessageInfo;
if (messageInfo != null)
{
messageInfo.ServerEndTimeStamp = DateTime.Now;
MessageBuffer mb = reply.CreateBufferedCopy(int.MaxValue);
Message responseMsg = mb.CreateMessage();
reply = mb.CreateMessage();
XmlDictionaryReader bodyReader = responseMsg.GetReaderAtBodyContents();
if (bodyReader.IsStartElement("Binary"))
{
bodyReader.ReadStartElement("Binary");
byte[] bodyBytes = bodyReader.ReadContentAsBase64();
messageInfo.Response = Encoding.UTF8.GetString(bodyBytes);
}
else
{
messageInfo.Response = bodyReader.ReadOuterXml();
}
if (reply.IsFault)
{
messageInfo.IsError = true;
}
if (messageInfo.Response.Contains("<Binary>"))
{
}
string message = String.Format("Response => {0} {1}", messageInfo.ServerEndTimeStamp.ToString(CultureInfo.InvariantCulture), messageInfo.Response);
if (IsDisplayConsole)
{
Console.WriteLine(message);
}
if (IsLogFile)
{
_logger.Log(LogLevel.Info, message);
}
}
if (OnMessage != null)
{
OnMessage(this, new MessageInspectorArgs
{
MessageInspectionType = MessageInspectionType.Response,
Message = messageInfo
});
}
}
}
/// <summary>
/// Extracts the message body as a string
/// </summary>
/// <param name="msg">The message from which the body will be extracted</param>
/// <param name="encoding">The encoding in which the body is expected to be</param>
/// <returns>The message body in string representation</returns>
public static string GetResponseBodyAsString(Message msg, Encoding encoding)
{
XmlDictionaryReader xdr = msg.GetReaderAtBodyContents();
xdr.ReadStartElement("MessageContent");
byte[] bodyBytes = xdr.ReadContentAsBase64();
return(encoding.GetString(bodyBytes, 0, bodyBytes.Length - 2));
}
public byte[] GetBytes(Message message, byte[] recyclableBuffer)
{
XmlDictionaryReader reader = message.GetReaderAtBodyContents();
int length;
while (!reader.HasValue)
{
reader.Read();
if (reader.EOF)
{
throw new InvalidDataException("empty XmlDictionaryReader");
}
}
if (reader.TryGetBase64ContentLength(out length))
{
byte[] bytes = null;
if (recyclableBuffer != null)
{
if (recyclableBuffer.Length == length)
{
// reuse
bytes = recyclableBuffer;
}
}
if (bytes == null)
{
bytes = new byte[length];
}
// this is the single copy mechanism from native to managed space with no intervening
// buffers. One could also write a method GetBytes(msg, myBuf, offset)...
reader.ReadContentAsBase64(bytes, 0, length);
reader.Close();
return(bytes);
}
else
{
// uses whatever default buffering mechanism is used by the base XmlDictionaryReader class
return(reader.ReadContentAsBase64());
}
}
public BinaryBodyReader(XmlDictionaryReader reader)
{
reader.ReadStartElement(BinaryElementName);
_data = reader.ReadContentAsBase64();
if (reader.NodeType == XmlNodeType.Text)
{
reader.Read();
}
reader.ReadEndElement();
}
