public void ReadRequestAndWriteResponse()
{
IPAddress[] addressList = Dns.GetHostEntry(Environment.MachineName).AddressList;
var endpoint = new IPEndPoint(addressList[addressList.Length - 1], 9900);
var listener = new TcpListener(endpoint);
listener.Start();
var t = new Thread(new ThreadStart(() =>
{
var c = listener.AcceptTcpClient();
var handle = new HttpProtocolHandle(c.GetStream());
//read remoting request
Trace.WriteLine(handle.ReadFirstLine());
DumpHelper.DumpDictionary(handle.ReadHeaders());
var messageRequest = BinaryFormatterHelper.DeserializeObject(handle.ReadContent()) as MethodCall;
//HACK:SoapFormatter not work well
//http://labs.developerfusion.co.uk/SourceViewer/browse.aspx?assembly=SSCLI&namespace=System.Runtime.Remoting
//var f = new System.Runtime.Serialization.Formatters.Soap.SoapFormatter();
//f.Context = new System.Runtime.Serialization.StreamingContext(System.Runtime.Serialization.StreamingContextStates.Other);
//var mc = new MethodCall(this.Parse(headers));
//var messageRequest = f.Deserialize(new System.IO.MemoryStream(content), new HeaderHandler(mc.HeaderHandler));
Assert.IsNotNull(messageRequest);
DumpHelper.DumpMessage(messageRequest);
//write remoting response
var responeMessage = new MethodResponse(new Header[] { new Header(MessageHeader.Return, messageRequest.Args[0]) }, messageRequest);
var responseStream = BinaryFormatterHelper.SerializeObject(responeMessage);
handle.WriteResponseFirstLine("200", "ok");
handle.WriteHeaders(new Dictionary<string, object>() { { HttpHeader.ContentLength, responseStream.Length } });
handle.WriteContent(responseStream);
//end httprequest
c.Close();
}));
t.Start();
//use BinaryFormatter via HTTP
var channel = new HttpChannel(new Hashtable(), new BinaryClientFormatterSinkProvider(), null);
ChannelServices.RegisterChannel(channel, false);
var url = string.Format("http://{0}/remote.rem", endpoint);
var service = RemotingServices.Connect(typeof(ServiceClass), url) as ServiceClass;
Assert.AreEqual("Hi", service.Do("Hi"));
t.Abort();
ChannelServices.UnregisterChannel(channel);
}
private LogicalCallContext FetchLogicalCallContext()
{
ReturnMessage message = this._crmsg as ReturnMessage;
if (message != null)
{
return(message.GetLogicalCallContext());
}
MethodResponse response = this._crmsg as MethodResponse;
if (response == null)
{
throw new RemotingException(Environment.GetResourceString("Remoting_Message_BadType"));
}
return(response.GetLogicalCallContext());
}
public void ReadRequestAndWriteResponse()
{
IPAddress[] addressList = Dns.GetHostEntry(Environment.MachineName).AddressList;
var endpoint = new IPEndPoint(addressList[addressList.Length - 1], 9900);
var listener = new TcpListener(endpoint);
listener.Start();
var t = new Thread(new ThreadStart(() =>
{
var c = listener.AcceptTcpClient();
var handle = new TcpProtocolHandle(c.GetStream());
//read remoting request
Console.WriteLine("Preamble: {0}", handle.ReadPreamble());
Console.WriteLine("MajorVersion: {0}", handle.ReadMajorVersion());
Console.WriteLine("MinorVersion: {0}", handle.ReadMinorVersion());
var op = handle.ReadOperation();
Assert.AreEqual(TcpOperations.Request, op);
Console.WriteLine("Operation: {0}", op);
Console.WriteLine("ContentDelimiter: {0}", handle.ReadContentDelimiter());
Console.WriteLine("ContentLength: {0}", handle.ReadContentLength());
DumpHelper.DumpDictionary(handle.ReadTransportHeaders());
var messageRequest = BinaryFormatterHelper.DeserializeObject(handle.ReadContent()) as MethodCall;
Assert.IsNotNull(messageRequest);
DumpHelper.DumpMessage(messageRequest);
//write remoting response
var responeMessage = new MethodResponse(new Header[] { new Header(MessageHeader.Return, messageRequest.Args[0]) }, messageRequest);
var responseStream = BinaryFormatterHelper.SerializeObject(responeMessage);
handle.WritePreamble();
handle.WriteMajorVersion();
handle.WriteMinorVersion();
handle.WriteOperation(TcpOperations.Reply);
handle.WriteContentDelimiter(TcpContentDelimiter.ContentLength);
handle.WriteContentLength(responseStream.Length);
handle.WriteTransportHeaders(null);
handle.WriteContent(responseStream);
}));
t.Start();
var url = string.Format("tcp://{0}/remote.rem", endpoint);
var service = RemotingServices.Connect(typeof(ServiceClass), url) as ServiceClass;
Assert.AreEqual("Hi", service.Do("Hi"));
t.Abort();
}
internal override void SetSpecialKey(int keyNum, object value)
{
ReturnMessage returnMessage = this._mrmsg as ReturnMessage;
MethodResponse methodResponse = this._mrmsg as MethodResponse;
if (keyNum != 0)
{
if (keyNum != 1)
{
throw new RemotingException(Environment.GetResourceString("Remoting_Default"));
}
if (returnMessage != null)
{
returnMessage.SetLogicalCallContext((LogicalCallContext)value);
return;
}
if (methodResponse != null)
{
methodResponse.SetLogicalCallContext((LogicalCallContext)value);
return;
}
throw new RemotingException(Environment.GetResourceString("Remoting_Message_BadType"));
}
else
{
if (returnMessage != null)
{
returnMessage.Uri = (string)value;
return;
}
if (methodResponse != null)
{
methodResponse.Uri = (string)value;
return;
}
throw new RemotingException(Environment.GetResourceString("Remoting_Message_BadType"));
}
}
internal static IMessage CheckReturnMessage (IMessage callMsg, IMessage retMsg)
{
#if NET_1_1
IMethodReturnMessage ret = retMsg as IMethodReturnMessage;
if (ret != null && ret.Exception != null)
{
if (RemotingConfiguration.CustomErrorsEnabled (IsLocalCall (callMsg)))
{
Exception ex = new Exception ("Server encountered an internal error. For more information, turn off customErrors in the server's .config file.");
retMsg = new MethodResponse (ex, (IMethodCallMessage)callMsg);
}
}
#endif
return retMsg;
}
#pragma warning restore 169
public virtual IMessage SyncProcessMessage(IMessage msgRequest)
{
IMessage retMessage = null;
try
{
// Time to transit into the "our" domain
byte [] arrResponse = null;
byte [] arrRequest = null;
CADMethodReturnMessage cadMrm = null;
CADMethodCallMessage cadMsg;
cadMsg = CADMethodCallMessage.Create (msgRequest);
if (null == cadMsg) {
// Serialize the request message
MemoryStream reqMsgStream = CADSerializer.SerializeMessage(msgRequest);
arrRequest = reqMsgStream.GetBuffer();
}
Context currentContext = Thread.CurrentContext;
try {
// InternalInvoke can't handle out arguments, this is why
// we return the results in a structure
ProcessMessageRes res = (ProcessMessageRes)AppDomain.InvokeInDomainByID (_domainID, processMessageMethod, null, new object [] { arrRequest, cadMsg });
arrResponse = res.arrResponse;
cadMrm = res.cadMrm;
} finally {
AppDomain.InternalSetContext (currentContext);
}
if (null != arrResponse) {
// Time to deserialize the message
MemoryStream respMsgStream = new MemoryStream(arrResponse);
// Deserialize the response message
retMessage = CADSerializer.DeserializeMessage(respMsgStream, msgRequest as IMethodCallMessage);
} else
retMessage = new MethodResponse (msgRequest as IMethodCallMessage, cadMrm);
}
catch (Exception e)
{
try
{
retMessage = new ReturnMessage (e, msgRequest as IMethodCallMessage);
}
catch (Exception)
{
// this is just to be sure
}
}
return retMessage;
}
#pragma warning disable 169
private static ProcessMessageRes ProcessMessageInDomain (
byte[] arrRequest,
CADMethodCallMessage cadMsg)
{
ProcessMessageRes res = new ProcessMessageRes ();
try
{
AppDomain.CurrentDomain.ProcessMessageInDomain (arrRequest, cadMsg, out res.arrResponse, out res.cadMrm);
}
catch (Exception e)
{
IMessage errorMsg = new MethodResponse (e, new ErrorMessage());
res.arrResponse = CADSerializer.SerializeMessage (errorMsg).GetBuffer();
}
return res;
}
[System.Security.SecurityCritical] // auto-generated
public virtual IMessage SyncProcessMessage(IMessage reqMsg)
{
Message.DebugOut("\n::::::::::::::::::::::::: CrossAppDomain Channel: Sync call starting");
IMessage errMsg = InternalSink.ValidateMessage(reqMsg);
if (errMsg != null)
{
return errMsg;
}
// currentPrincipal is used to save the current principal. It should be
// restored on the reply message.
IPrincipal currentPrincipal = null;
IMessage desRetMsg = null;
try
{
IMethodCallMessage mcmReqMsg = reqMsg as IMethodCallMessage;
if (mcmReqMsg != null)
{
LogicalCallContext lcc = mcmReqMsg.LogicalCallContext;
if (lcc != null)
{
// Special case Principal since if might not be serializable
currentPrincipal = lcc.RemovePrincipalIfNotSerializable();
}
}
MemoryStream reqStm = null;
SmuggledMethodCallMessage smuggledMcm = SmuggledMethodCallMessage.SmuggleIfPossible(reqMsg);
if (smuggledMcm == null)
{
//*********************** SERIALIZE REQ-MSG ****************
// Deserialization of objects requires permissions that users
// of remoting are not guaranteed to possess. Since remoting
// can guarantee that it's users can't abuse deserialization
// (since it won't allow them to pass in raw blobs of
// serialized data), it should assert the permissions
// necessary before calling the deserialization code. This
// will terminate the security stackwalk caused when
// serialization checks for the correct permissions at the
// remoting stack frame so the check won't continue on to
// the user and fail. <EMAIL>[from Microsoft]</EMAIL>
// We will hold off from doing this for x-process channels
// until the big picture of distributed security is finalized.
reqStm = CrossAppDomainSerializer.SerializeMessage(reqMsg);
}
// Retrieve calling caller context here, where it is safe from the view
// of app domain checking code
LogicalCallContext oldCallCtx = CallContext.SetLogicalCallContext(null);
// Call helper method here, to avoid confusion with stack frames & app domains
MemoryStream retStm = null;
byte[] responseBytes = null;
SmuggledMethodReturnMessage smuggledMrm;
try
{
if (smuggledMcm != null)
responseBytes = DoTransitionDispatch(null, smuggledMcm, out smuggledMrm);
else
responseBytes = DoTransitionDispatch(reqStm.GetBuffer(), null, out smuggledMrm);
}
finally
{
CallContext.SetLogicalCallContext(oldCallCtx);
}
if (smuggledMrm != null)
{
ArrayList deserializedArgs = smuggledMrm.FixupForNewAppDomain();
desRetMsg = new MethodResponse((IMethodCallMessage)reqMsg,
smuggledMrm,
deserializedArgs);
}
else
{
if (responseBytes != null) {
retStm = new MemoryStream(responseBytes);
Message.DebugOut("::::::::::::::::::::::::::: CrossAppDomain Channel: Sync call returning!!\n");
//*********************** DESERIALIZE RET-MSG **************
desRetMsg = CrossAppDomainSerializer.DeserializeMessage(retStm, reqMsg as IMethodCallMessage);
}
}
}
catch(Exception e)
{
Message.DebugOut("Arrgh.. XAppDomainSink::throwing exception " + e + "\n");
try
{
desRetMsg = new ReturnMessage(e, (reqMsg as IMethodCallMessage));
}
catch(Exception )
{
// Fatal Error .. can't do much here
}
}
// restore the principal if necessary.
if (currentPrincipal != null)
{
IMethodReturnMessage mrmRetMsg = desRetMsg as IMethodReturnMessage;
if (mrmRetMsg != null)
{
LogicalCallContext lcc = mrmRetMsg.LogicalCallContext;
lcc.Principal = currentPrincipal;
}
}
return desRetMsg;
}
// used by the client
internal IMessage FormatResponse(ISoapMessage soapMsg, IMethodCallMessage mcm)
{
IMessage rtnMsg;
if(soapMsg.MethodName == "Fault") {
// an exception was thrown by the server
Exception e = new SerializationException();
int i = Array.IndexOf(soapMsg.ParamNames, "detail");
if(_serverFaultExceptionField != null)
// todo: revue this 'cause it's not safe
e = (Exception) _serverFaultExceptionField.GetValue(
soapMsg.ParamValues[i]);
rtnMsg = new ReturnMessage((System.Exception)e, mcm);
}
else {
object rtnObject = null;
//RemMessageType messageType;
// Get the output of the function if it is not *void*
if(_methodCallInfo.ReturnType != typeof(void)){
int index = Array.IndexOf(soapMsg.ParamNames, "return");
rtnObject = soapMsg.ParamValues[index];
if(rtnObject is IConvertible)
rtnObject = Convert.ChangeType(
rtnObject,
_methodCallInfo.ReturnType);
}
object[] outParams = new object [_methodCallParameters.Length];
int n=0;
// check if there are *out* parameters
foreach(ParameterInfo paramInfo in _methodCallParameters) {
if(paramInfo.ParameterType.IsByRef || paramInfo.IsOut) {
int index = Array.IndexOf(soapMsg.ParamNames, paramInfo.Name);
object outParam = soapMsg.ParamValues[index];
if(outParam is IConvertible)
outParam = Convert.ChangeType (outParam, paramInfo.ParameterType.GetElementType());
outParams[n] = outParam;
}
else
outParams [n] = null;
n++;
}
Header[] headers = new Header [2 + (soapMsg.Headers != null ? soapMsg.Headers.Length : 0)];
headers [0] = new Header ("__Return", rtnObject);
headers [1] = new Header ("__OutArgs", outParams);
if (soapMsg.Headers != null)
soapMsg.Headers.CopyTo (headers, 2);
rtnMsg = new MethodResponse (headers, mcm);
}
return rtnMsg;
}
internal static IMessage DeserializeMessage(String mimeType, Stream xstm, bool methodRequest, IMessage msg, Header[] h)
{
InternalRemotingServices.RemotingTrace("DeserializeMessage");
InternalRemotingServices.RemotingTrace("MimeType: " + mimeType);
CoreChannel.DebugOutXMLStream(xstm, "Deserializing");
Stream fmtStm = null;
bool bin64encode = false;
bool doHeaderBodyAsOne = true;
if (string.Compare(mimeType, BinaryMimeType, StringComparison.Ordinal) == 0)
{
doHeaderBodyAsOne = true;
}
if (string.Compare(mimeType, SOAPMimeType, StringComparison.Ordinal) == 0)
{
doHeaderBodyAsOne = false;
}
if (bin64encode == false)
{
fmtStm = xstm;
}
else
{
InternalRemotingServices.RemotingTrace("***************** Before base64 decode *****");
long Position = xstm.Position;
MemoryStream inStm = (MemoryStream)xstm;
byte[] byteArray = inStm.ToArray();
xstm.Position = Position;
String base64String = Encoding.ASCII.GetString(byteArray,0, byteArray.Length);
byte[] byteArrayContent = Convert.FromBase64String(base64String);
MemoryStream memStm = new MemoryStream(byteArrayContent);
fmtStm = memStm;
InternalRemotingServices.RemotingTrace("***************** after base64 decode *****");
}
Object ret;
IRemotingFormatter fmt = MimeTypeToFormatter(mimeType, false);
if (doHeaderBodyAsOne == true)
{
ret = ((BinaryFormatter)fmt).UnsafeDeserializeMethodResponse(fmtStm, null, (IMethodCallMessage)msg);
}
else
{
InternalRemotingServices.RemotingTrace("Content");
InternalRemotingServices.RemotingTrace("***************** Before Deserialize Headers *****");
InternalRemotingServices.RemotingTrace("***************** After Deserialize Headers *****");
InternalRemotingServices.RemotingTrace("***************** Before Deserialize Message *****");
if (methodRequest == true)
{
MethodCall mc = new MethodCall(h);
InternalRemotingServices.RemotingTrace("***************** Before Deserialize Message - as MethodCall *****");
fmt.Deserialize(fmtStm, new HeaderHandler(mc.HeaderHandler));
ret = mc;
}
else
{
IMethodCallMessage mcm = (IMethodCallMessage)msg;
MethodResponse mr = new MethodResponse(h, mcm);
InternalRemotingServices.RemotingTrace("***************** Before Deserialize Message - as MethodResponse *****");
fmt.Deserialize(fmtStm, new HeaderHandler(mr.HeaderHandler));
ret = mr;
}
InternalRemotingServices.RemotingTrace("***************** After Deserialize Message *****");
}
// Workaround to make this method verifiable
IMessage resMessage = (IMessage) ret;
InternalRemotingServices.RemotingTrace("CoreChannel::DeserializeMessage OUT");
CoreChannel.DebugMessage(resMessage);
return resMessage;
}
} // DeserializeSoapRequestMessage
internal static IMessage DeserializeSoapResponseMessage(
Stream inputStream, IMessage requestMsg, Header[] h, bool bStrictBinding)
{
SoapFormatter fmt = CreateSoapFormatter(false, bStrictBinding);
IMethodCallMessage mcm = (IMethodCallMessage)requestMsg;
MethodResponse mr = new MethodResponse(h, mcm);
fmt.Deserialize(inputStream, new HeaderHandler(mr.HeaderHandler));
IMessage resMessage = (IMessage)mr;
return resMessage;
} // DeserializeSoapResponseMessage
internal static IMessage DeserializeMessage(string mimeType, Stream xstm, bool methodRequest, IMessage msg, Header[] h)
{
Stream serializationStream = null;
object obj2;
bool flag = false;
bool flag2 = true;
if (string.Compare(mimeType, "application/octet-stream", StringComparison.Ordinal) == 0)
{
flag2 = true;
}
if (string.Compare(mimeType, "text/xml", StringComparison.Ordinal) == 0)
{
flag2 = false;
}
if (!flag)
{
serializationStream = xstm;
}
else
{
long position = xstm.Position;
byte[] bytes = ((MemoryStream) xstm).ToArray();
xstm.Position = position;
MemoryStream stream3 = new MemoryStream(Convert.FromBase64String(Encoding.ASCII.GetString(bytes, 0, bytes.Length)));
serializationStream = stream3;
}
IRemotingFormatter formatter = MimeTypeToFormatter(mimeType, false);
if (flag2)
{
obj2 = ((BinaryFormatter) formatter).UnsafeDeserializeMethodResponse(serializationStream, null, (IMethodCallMessage) msg);
}
else if (methodRequest)
{
MethodCall call = new MethodCall(h);
formatter.Deserialize(serializationStream, new HeaderHandler(call.HeaderHandler));
obj2 = call;
}
else
{
IMethodCallMessage mcm = (IMethodCallMessage) msg;
MethodResponse response = new MethodResponse(h, mcm);
formatter.Deserialize(serializationStream, new HeaderHandler(response.HeaderHandler));
obj2 = response;
}
return (IMessage) obj2;
}
public virtual IMessage SyncProcessMessage(IMessage reqMsg)
{
IMessage message = InternalSink.ValidateMessage(reqMsg);
if (message != null)
{
return message;
}
IPrincipal principal = null;
IMessage message2 = null;
try
{
SmuggledMethodReturnMessage message5;
IMethodCallMessage message3 = reqMsg as IMethodCallMessage;
if (message3 != null)
{
LogicalCallContext logicalCallContext = message3.LogicalCallContext;
if (logicalCallContext != null)
{
principal = logicalCallContext.RemovePrincipalIfNotSerializable();
}
}
MemoryStream stream = null;
SmuggledMethodCallMessage smuggledMcm = SmuggledMethodCallMessage.SmuggleIfPossible(reqMsg);
if (smuggledMcm == null)
{
stream = CrossAppDomainSerializer.SerializeMessage(reqMsg);
}
LogicalCallContext callCtx = CallContext.SetLogicalCallContext(null);
MemoryStream stm = null;
byte[] buffer = null;
try
{
if (smuggledMcm != null)
{
buffer = this.DoTransitionDispatch(null, smuggledMcm, out message5);
}
else
{
buffer = this.DoTransitionDispatch(stream.GetBuffer(), null, out message5);
}
}
finally
{
CallContext.SetLogicalCallContext(callCtx);
}
if (message5 != null)
{
ArrayList deserializedArgs = message5.FixupForNewAppDomain();
message2 = new MethodResponse((IMethodCallMessage) reqMsg, message5, deserializedArgs);
}
else if (buffer != null)
{
stm = new MemoryStream(buffer);
message2 = CrossAppDomainSerializer.DeserializeMessage(stm, reqMsg as IMethodCallMessage);
}
}
catch (Exception exception)
{
try
{
message2 = new ReturnMessage(exception, reqMsg as IMethodCallMessage);
}
catch (Exception)
{
}
}
if (principal != null)
{
IMethodReturnMessage message6 = message2 as IMethodReturnMessage;
if (message6 != null)
{
message6.LogicalCallContext.Principal = principal;
}
}
return message2;
}
void ProcessReceive(SocketAsyncEventArgs e)
{
if (e.BytesTransferred > 0)
{
if (e.SocketError == SocketError.Success)
{
totalBuffer = Combine(totalBuffer, e.Buffer);
if (e.AcceptSocket.Available == 0)
{
//.Net Remoting Protocol Parser
#region Read Request
Console.WriteLine("==== .Net Remoting Protocol Parser ====");
//1. Preamble, will be ".NET"
Console.WriteLine("Preamble: {0}", Encoding.ASCII.GetString(new byte[] {
totalBuffer[0],
totalBuffer[1],
totalBuffer[2],
totalBuffer[3] }));
//2. MajorVersion, will be 1
Console.WriteLine("MajorVersion: {0}", totalBuffer[4]);
//3. MinorVersion, will be 0
Console.WriteLine("MinorVersion: {0}", totalBuffer[5]);
//4. Operation, will be 5 (request,onewayrequest...)
Console.WriteLine("Operation: {0}", (UInt16)(totalBuffer[6] & 0xFF | totalBuffer[7] << 8));
//5. TcpContentDelimiter and ContentLength
var header = (UInt16)(totalBuffer[8] & 0xFF | totalBuffer[9] << 8);
if (header == 1)
Console.WriteLine("Chunked: {0}", true);
else
Console.WriteLine("ContentLength: {0}"
, (int)((totalBuffer[10] & 0xFF)
| totalBuffer[11] << 8
| totalBuffer[12] << 16
| totalBuffer[13] << 24));
#region 6. ReadHeaders ITransportHeaders
Console.WriteLine("---- ITransportHeaders ----");
var index = header == 1 ? 9 : 13;
var headerType = ReadUInt16(ref index);
while (headerType != TcpHeaders.EndOfHeaders)
{
if (headerType == TcpHeaders.Custom)
{
Console.WriteLine("{0}: {1}", ReadCountedString(ref index), ReadCountedString(ref index));
}
else if (headerType == TcpHeaders.RequestUri)
{
Console.WriteLine("RequestUri-Format: {0}", ReadByte(ref index));
Console.WriteLine("RequestUri: {0}", ReadCountedString(ref index));
}
else if (headerType == TcpHeaders.StatusCode)
{
Console.WriteLine("StatusCode-Format: {0}", ReadByte(ref index));
var code = ReadUInt16(ref index);
Console.WriteLine("StatusCode: {0}", code);
//if (code != 0) error = true;
}
else if (headerType == TcpHeaders.StatusPhrase)
{
Console.WriteLine("StatusPhrase-Format: {0}", ReadByte(ref index));
Console.WriteLine("StatusPhrase: {0}", ReadCountedString(ref index));
}
else if (headerType == TcpHeaders.ContentType)
{
Console.WriteLine("ContentType-Format: {0}", ReadByte(ref index));
Console.WriteLine("ContentType: {0}", ReadCountedString(ref index));
}
else
{
var headerFormat = (byte)ReadByte(ref index);
switch (headerFormat)
{
case TcpHeaderFormat.Void: break;
case TcpHeaderFormat.CountedString: ReadCountedString(ref index); break;
case TcpHeaderFormat.Byte: ReadByte(ref index); break;
case TcpHeaderFormat.UInt16: ReadUInt16(ref index); break;
case TcpHeaderFormat.Int32: ReadInt32(ref index); break;
default:
throw new RemotingException("Remoting_Tcp_UnknownHeaderType");
}
}
headerType = ReadUInt16(ref index);
}
#endregion
//7. RequestStream/Message
var requestStream = new byte[totalBuffer.Length - index - 1];
Buffer.BlockCopy(totalBuffer, index + 1, requestStream, 0, totalBuffer.Length - index - 1);
//using BinaryFormatterSink default
var requestMessage = BinaryFormatterHelper.DeserializeObject(requestStream) as MethodCall;
DumpHelper.DumpMessage(requestMessage);
#endregion
buffers = new StringBuilder();
totalBuffer = new byte[0];
#region Write Response
//http://labs.developerfusion.co.uk/SourceViewer/browse.aspx?assembly=SSCLI&namespace=System.Runtime.Remoting
//else if (name.Equals("__Return"))
var responeMessage = new MethodResponse(
//just return args[0]
new Header[] { new Header("__Return", requestMessage.Args[0]) }
, requestMessage);
//responeMessage.ReturnValue//can not set
var responseStream = BinaryFormatterHelper.SerializeObject(responeMessage);
//1.Preamble
var preamble = Encoding.ASCII.GetBytes(".NET");
foreach (var b in preamble)
WriteByte(b);
//2.MajorVersion
WriteByte((byte)1);
//3.MinorVersion
WriteByte((byte)0);
//4.Operation
WriteUInt16(TcpOperations.Reply);
//5.TcpContentDelimiter and ContentLength
WriteUInt16(0);
WriteInt32(responseStream.Length);
//6.Headers
WriteUInt16(TcpHeaders.EndOfHeaders);
//7.ResponseStream/Message
foreach (var b in responseStream)
WriteByte(b);
#endregion
e.SetBuffer(totalBuffer, 0, totalBuffer.Length);
if (!e.AcceptSocket.SendAsync(e))
{
this.ProcessSend(e);
}
}
else if (!e.AcceptSocket.ReceiveAsync(e))
{
this.ProcessReceive(e);
}
}
else
{
//this.ProcessError(e);
}
}
else
{
//this.CloseClientSocket(e);
}
}
