/// <summary>
/// Writes an AMF header.
/// </summary>
/// <param name="output">The output stream</param>
/// <param name="header">The header to write</param>
private static void WriteAMFHeader(AMFDataOutput output, AMFHeader header)
{
output.WriteShortString(header.Name);
output.WriteBoolean(header.MustUnderstand);
output.WriteUnsignedInt(0xffffffff); // header length ignored
WriteAMFContent(output, header.Content);
}
public override void SetUp()
{
base.SetUp();
stream = new MemoryStream();
serializer = Mocks.CreateMock<IActionScriptSerializer>();
output = new AMFDataOutput(stream, serializer);
}
public AMF3ObjectWriter(AMFDataOutput output)
{
this.output = output;
classDefinitionCache = new Dictionary<ASClass, int>(ReferenceEqualityComparer<ASClass>.Instance);
objectReferenceCache = new Dictionary<IASValue, CacheItem>(ReferenceEqualityComparer<IASValue>.Instance);
stringReferenceCache = new Dictionary<string, int>(StringComparer.Ordinal);
}
/// <summary>
/// Writes an AMF body.
/// </summary>
/// <param name="output">The output stream</param>
/// <param name="body">The body to write</param>
private static void WriteAMFBody(AMFDataOutput output, AMFBody body)
{
output.WriteShortString(body.RequestTarget);
output.WriteShortString(body.ResponseTarget);
output.WriteUnsignedInt(0xffffffff); // body length ignored
WriteAMFContent(output, body.Content);
}
/// <summary>
/// Writes an AMF header.
/// </summary>
/// <param name="output">The output stream</param>
/// <param name="header">The header to write</param>
private static void WriteAMFHeader(AMFDataOutput output, AMFHeader header)
{
output.WriteShortString(header.Name);
output.WriteBoolean(header.MustUnderstand);
output.WriteUnsignedInt(0xffffffff); // header length ignored
WriteAMFContent(output, header.Content);
}
public AMF3ObjectWriter(AMFDataOutput output)
{
this.output = output;
classDefinitionCache = new Dictionary <ASClass, int>(ReferenceEqualityComparer <ASClass> .Instance);
objectReferenceCache = new Dictionary <IASValue, CacheItem>(ReferenceEqualityComparer <IASValue> .Instance);
stringReferenceCache = new Dictionary <string, int>(StringComparer.Ordinal);
}
/// <summary>
/// Writes an AMF message to an output stream and bubbles up exceptions.
/// </summary>
/// <param name="output">The output stream</param>
/// <param name="message">The message to write</param>
private static void UncheckedWriteAMFMessage(AMFDataOutput output, AMFMessage message)
{
output.WriteUnsignedShort(message.Version);
output.WriteUnsignedShort((ushort)message.Headers.Count);
foreach (AMFHeader header in message.Headers)
WriteAMFHeader(output, header);
output.WriteUnsignedShort((ushort)message.Bodies.Count);
foreach (AMFBody body in message.Bodies)
WriteAMFBody(output, body);
}
/// <summary>
/// Writes AMF content.
/// </summary>
/// <param name="output">The output stream</param>
/// <param name="content">The content to write</param>
private static void WriteAMFContent(AMFDataOutput output, IASValue content)
{
output.BeginObjectStream();
try
{
output.WriteObject(content);
}
finally
{
output.EndObjectStream();
}
}
/// <summary>
/// Writes an AMF message to an output stream.
/// </summary>
/// <param name="output">The output stream</param>
/// <param name="message">The message to write</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="output"/> or
/// <paramref name="message"/> is null</exception>
/// <exception cref="AMFException">Thrown if an exception occurred while writing the message</exception>
public static void WriteAMFMessage(AMFDataOutput output, AMFMessage message)
{
if (output == null)
throw new ArgumentNullException("output");
if (message == null)
throw new ArgumentNullException("message");
try
{
UncheckedWriteAMFMessage(output, message);
}
catch (Exception ex)
{
throw new AMFException("An exception occurred while writing an AMF message to the stream.", ex);
}
}
/// <summary>
/// Writes an AMF message to an output stream and bubbles up exceptions.
/// </summary>
/// <param name="output">The output stream</param>
/// <param name="message">The message to write</param>
private static void UncheckedWriteAMFMessage(AMFDataOutput output, AMFMessage message)
{
output.WriteUnsignedShort(message.Version);
output.WriteUnsignedShort((ushort)message.Headers.Count);
foreach (AMFHeader header in message.Headers)
{
WriteAMFHeader(output, header);
}
output.WriteUnsignedShort((ushort)message.Bodies.Count);
foreach (AMFBody body in message.Bodies)
{
WriteAMFBody(output, body);
}
}
/// <summary>
/// Writes an AMF message to an output stream.
/// </summary>
/// <param name="output">The output stream</param>
/// <param name="message">The message to write</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="output"/> or
/// <paramref name="message"/> is null</exception>
/// <exception cref="AMFException">Thrown if an exception occurred while writing the message</exception>
public static void WriteAMFMessage(AMFDataOutput output, AMFMessage message)
{
if (output == null)
{
throw new ArgumentNullException("output");
}
if (message == null)
{
throw new ArgumentNullException("message");
}
try
{
UncheckedWriteAMFMessage(output, message);
}
catch (Exception ex)
{
throw new AMFException("An exception occurred while writing an AMF message to the stream.", ex);
}
}
protected override IEnumerable<Step> GetSteps()
{
// Set properties from context.
context.Request.IsSecureConnection = context.HttpContext.Request.IsSecureConnection;
// Read the AMF message and prepare the response context.
AMFDataInput dataInput = new AMFDataInput(context.HttpContext.Request.InputStream, context.Serializer);
AMFMessage amfRequestMessage = AMFMessageReader.ReadAMFMessage(dataInput);
context.Request.SetMessage(amfRequestMessage);
context.Response.PrepareResponseMessage(amfRequestMessage);
// Process all message bodies.
foreach (AMFBody requestBody in amfRequestMessage.Bodies)
{
object nativeContent;
try
{
nativeContent = context.Serializer.ToNative(requestBody.Content, null);
}
catch (Exception ex)
{
context.Response.AddErrorResponse(requestBody.ResponseTarget,
"An error occurred while deserializing the request body.", ex);
continue;
}
if (requestBody.RequestTarget == "null")
{
IMessage requestMessage = nativeContent as IMessage;
if (requestMessage == null)
{
object[] array = nativeContent as object[];
if (array != null)
requestMessage = array[0] as IMessage;
if (requestMessage != null)
{
IAsyncResult result;
try
{
result = messageBroker.BeginProcessRequest(context, requestMessage, OnAsyncResultCallbackResume, null);
}
catch (Exception ex)
{
ErrorMessage errorMessage = ErrorMessage.CreateErrorResponse(requestMessage,
"An error occurred while the message broker was processing the message.",
"Gateway.MessageBroker.BeginProcessRequestFailed",
ex);
context.Response.AddErrorResponse(requestBody.ResponseTarget, errorMessage);
continue;
}
yield return new Step("Waiting for message broker.");
try
{
IMessage responseMessage = messageBroker.EndProcessRequest(result);
context.Response.AddResultResponse(requestBody.ResponseTarget, responseMessage);
}
catch (Exception ex)
{
ErrorMessage errorMessage = ErrorMessage.CreateErrorResponse(requestMessage,
"An error occurred while the message broker was processing the message.",
"Gateway.MessageBroker.EndProcessRequestFailed",
ex);
context.Response.AddErrorResponse(requestBody.ResponseTarget, errorMessage);
}
continue;
}
}
}
// Don't know what to do with this message.
context.Response.AddErrorResponse(requestBody.ResponseTarget,
String.Format(CultureInfo.CurrentCulture,
"Received a message for unsupported request target '{0}'.", requestBody.RequestTarget), null);
}
// Generate the response.
AMFDataOutput dataOutput = new AMFDataOutput(context.HttpContext.Response.OutputStream, context.Serializer);
AMFMessageWriter.WriteAMFMessage(dataOutput, context.Response.Message);
context.HttpContext.Response.ContentType = AMFContentType;
context.HttpContext.Response.Cache.SetCacheability(HttpCacheability.NoCache);
yield break;
}
/// <summary>
/// Writes an AMF body.
/// </summary>
/// <param name="output">The output stream</param>
/// <param name="body">The body to write</param>
private static void WriteAMFBody(AMFDataOutput output, AMFBody body)
{
output.WriteShortString(body.RequestTarget);
output.WriteShortString(body.ResponseTarget);
output.WriteUnsignedInt(0xffffffff); // body length ignored
WriteAMFContent(output, body.Content);
}
private byte[] ToAMF(object nativeValue)
{
IActionScriptSerializer serializer = serializerFactory.CreateSerializer();
IASValue asValue = serializer.ToASValue(nativeValue);
MemoryStream stream = new MemoryStream();
AMFDataOutput dataOutput = new AMFDataOutput(stream, serializer);
dataOutput.ObjectEncoding = AMFObjectEncoding.AMF3;
dataOutput.BeginObjectStream();
dataOutput.WriteObject(asValue);
dataOutput.EndObjectStream();
return stream.ToArray();
}
/// <summary>
/// Writes AMF content.
/// </summary>
/// <param name="output">The output stream</param>
/// <param name="content">The content to write</param>
private static void WriteAMFContent(AMFDataOutput output, IASValue content)
{
output.BeginObjectStream();
try
{
output.WriteObject(content);
}
finally
{
output.EndObjectStream();
}
}
public AMF0ObjectWriter(AMFDataOutput output)
{
this.output = output;
referenceCache = new Dictionary <IASValue, int>(ReferenceEqualityComparer <IASValue> .Instance);
}
public AMF0ObjectWriter(AMFDataOutput output)
{
this.output = output;
referenceCache = new Dictionary<IASValue, int>(ReferenceEqualityComparer<IASValue>.Instance);
}