public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack,
IMessage requestMsg,
ITransportHeaders requestHeaders, Stream requestStream,
out IMessage responseMsg, out ITransportHeaders responseHeaders,
out Stream responseStream)
{
if (requestMsg != null)
{
// The message has already been deserialized so delegate to the next sink.
return(_nextSink.ProcessMessage(
sinkStack,
requestMsg, requestHeaders, requestStream,
out responseMsg, out responseHeaders, out responseStream));
}
SdlType sdlType;
if (!ShouldIntercept(requestHeaders, out sdlType))
{
return(_nextSink.ProcessMessage(sinkStack, null, requestHeaders, requestStream,
out responseMsg, out responseHeaders, out responseStream));
}
// generate sdl and return it
responseHeaders = new TransportHeaders();
GenerateSdl(sdlType, sinkStack, requestHeaders, responseHeaders, out responseStream);
responseMsg = null;
return(ServerProcessing.Complete);
} // ProcessMessage
public IPEndPoint Read(out ITransportHeaders headers, out Stream stream, out IPEndPoint remote)
{
// FIXME: 1) reliability 2) exceptions
remote = new IPEndPoint(IPAddress.Loopback, 0);
var buffer = UdpClient.Receive(ref remote);
using (var ms = new MemoryStream(buffer))
using (var br = new BinaryReader(ms))
{
var marker = br.ReadInt16();
if (marker != HeaderMarker && marker != DataMarker)
{
throw new InvalidDataException("Unexpected datagram format");
}
// read transport headers
headers = new TransportHeaders();
while (marker != DataMarker)
{
var name = br.ReadString();
var value = br.ReadString();
headers[name] = value;
marker = br.ReadInt16();
}
// get response stream
var length = br.ReadInt32();
stream = new MemoryStream(buffer, (int)ms.Position, length);
}
return(remote);
}
private void SerializeResponse(IMessage responseMsg, ref ITransportHeaders responseHeaders, ref Stream responseStream, IXmlRpcStreamRequestConfig config)
{
XmlRpcResponseSerializer serializer = new XmlRpcResponseSerializer();
responseStream = new MemoryStream();
responseHeaders = new TransportHeaders();
ReturnMessage retMsg = (ReturnMessage)responseMsg;
XmlRpcResponse response;
if (retMsg.Exception == null)
{
response = new XmlRpcResponse(retMsg.ReturnValue);
}
else if (retMsg.Exception is XmlRpcException)
{
response = new XmlRpcResponse();
response.Fault = (retMsg.Exception as XmlRpcException).Fault;
}
else
{
response = new XmlRpcResponse();
response.Fault = new XmlRpcFault(1, retMsg.Exception.Message);
}
serializer.WriteResponse(responseStream, response, config, TypeSerializerFactory);
responseHeaders["Content-Type"] = "text/xml; charset=\"utf-8\"";
}
public IMessage SyncProcessMessage(IMessage msg)
{
try {
ITransportHeaders call_headers = new TransportHeaders();
call_headers["__RequestUri"] = ((IMethodCallMessage)msg).Uri;
call_headers["Content-Type"] = "application/octet-stream";
Stream call_stream = _nextInChain.GetRequestStream(msg, call_headers);
if (call_stream == null)
{
call_stream = new MemoryStream();
}
// Serialize msg to the stream
_binaryCore.Serializer.Serialize(call_stream, msg, null);
if (call_stream is MemoryStream)
{
call_stream.Position = 0;
}
Stream response_stream;
ITransportHeaders response_headers;
_nextInChain.ProcessMessage(msg, call_headers, call_stream, out response_headers,
out response_stream);
// Deserialize response_stream
return((IMessage)_binaryCore.Deserializer.DeserializeMethodResponse(response_stream, null, (IMethodCallMessage)msg));
} catch (Exception e) {
return(new ReturnMessage(e, (IMethodCallMessage)msg));
}
}
} // SendContinue
public void SendResponse(Stream httpContentStream,
String statusCode, String reasonPhrase,
ITransportHeaders headers)
{
if (_responseStream != null)
{
_responseStream.Close();
if (_responseStream != httpContentStream)
{
throw new RemotingException(
CoreChannel.GetResourceString("Remoting_Http_WrongResponseStream"));
}
// we are done with the response stream
_responseStream = null;
}
else
{
if (headers == null)
{
headers = new TransportHeaders();
}
String serverHeader = (String)headers["Server"];
if (serverHeader != null)
{
serverHeader = HttpServerTransportSink.ServerHeader + ", " + serverHeader;
}
else
{
serverHeader = HttpServerTransportSink.ServerHeader;
}
headers["Server"] = serverHeader;
// Add length to response headers if necessary
if (!AllowChunkedResponse && (httpContentStream != null))
{
headers["Content-Length"] = httpContentStream.Length.ToString(CultureInfo.InvariantCulture);
}
else
if (httpContentStream == null)
{
headers["Content-Length"] = "0";
}
GetResponseStream(statusCode, reasonPhrase, headers);
// write HTTP content
if (httpContentStream != null)
{
StreamHelper.CopyStream(httpContentStream, _responseStream);
_responseStream.Close();
httpContentStream.Close();
}
// we are done with the response stream
_responseStream = null;
}
} // SendResponse
public ITransportHeaders ReadHeaders()
{
TransportHeaders headers = new TransportHeaders();
// read uri (and make sure that no channel specific data is present)
String uri = ReadString();
if (uri != "" && uri != null)
{
String chanuri, objuri;
chanuri = PipeConnection.Parse(uri, out objuri);
if (chanuri == null)
{
objuri = uri;
}
headers[CommonTransportKeys.RequestUri] = objuri;
}
// read to end of headers
ushort marker = ReadUShort();
while (marker == HeaderMarker)
{
String hname = ReadString();
String hvalue = ReadString();
headers[hname] = hvalue;
marker = ReadUShort();
}
return(headers);
}
public void ProcessMessage(IMessage msg, ITransportHeaders requestHeaders, Stream requestStream, out ITransportHeaders responseHeaders, out Stream responseStream)
{
UnixConnection connection = null;
try
{
if (requestHeaders == null)
{
requestHeaders = new TransportHeaders();
}
requestHeaders["__RequestUri"] = ((IMethodMessage)msg).Uri;
connection = UnixConnectionPool.GetConnection(this._path);
UnixMessageIO.SendMessageStream(connection.Stream, requestStream, requestHeaders, connection.Buffer);
connection.Stream.Flush();
if (UnixMessageIO.ReceiveMessageStatus(connection.Stream, connection.Buffer) != MessageStatus.MethodMessage)
{
throw new RemotingException("Unknown response message from server");
}
responseStream = UnixMessageIO.ReceiveMessageStream(connection.Stream, out responseHeaders, connection.Buffer);
}
finally
{
if (connection != null)
{
connection.Release();
}
}
}
void SerializeResponse(
IMessage responseMsg,
ref ITransportHeaders responseHeaders,
ref Stream responseStream)
{
XmlRpcResponseSerializer serializer = new XmlRpcResponseSerializer();
responseStream = new MemoryStream();
responseHeaders = new TransportHeaders();
ReturnMessage retMsg = (ReturnMessage)responseMsg;
if (retMsg.Exception == null)
{
XmlRpcResponse xmlRpcResp = new XmlRpcResponse(retMsg.ReturnValue);
serializer.SerializeResponse(responseStream, xmlRpcResp);
}
else if (retMsg.Exception is XmlRpcFaultException)
{
serializer.SerializeFaultResponse(responseStream,
(XmlRpcFaultException)retMsg.Exception);
}
else
{
serializer.SerializeFaultResponse(responseStream,
new XmlRpcFaultException(1, retMsg.Exception.Message));
}
responseHeaders["Content-Type"] = "text/xml; charset=\"utf-8\"";
}
public IMessage SyncProcessMessage(IMessage msg)
{
IMethodCallMessage mcall = msg as IMethodCallMessage;
Trace.WriteLine("IceClientFormatterSink: ProcessMessage: " + mcall.MethodBase);
try {
Stream msgStream;
FormatMessage(msg, out msgStream);
// send downstream for processing
TransportHeaders reqHeaders = new TransportHeaders();
ITransportHeaders respHeaders;
Stream respStream;
_next.ProcessMessage(msg, reqHeaders, msgStream, out respHeaders, out respStream);
// convert back into a response message
IMessage result = (IMessage)IceChannelUtils.ProtocolReplyToMessage(respStream, msg);
respStream.Close();
return(result);
} catch (Exception e) {
return(new ReturnMessage(e, mcall));
}
}
} // SendContinue
public void SendResponse(Stream httpContentStream,
String statusCode, String reasonPhrase,
ITransportHeaders headers)
{
if (_responseStream != null)
{
_responseStream.Close();
if (_responseStream != httpContentStream)
{
throw new RemotingException(
"Http transport sink was not given the stream that it returned from GetResponseStream().");
}
// we are done with the response stream
_responseStream = null;
}
else
{
if (headers == null)
{
headers = new TransportHeaders();
}
String serverHeader = (String)headers["Server"];
if (serverHeader != null)
{
serverHeader = HttpServerTransportSink.ServerHeader + ", " + serverHeader;
}
else
{
serverHeader = HttpServerTransportSink.ServerHeader;
}
headers["Server"] = serverHeader;
// Add length to response headers if necessary
if (!AllowChunkedResponse && (httpContentStream != null))
{
headers["Content-Length"] = httpContentStream.Length.ToString();
}
else
if (httpContentStream == null)
{
headers["Content-Length"] = "0";
}
GetResponseStream(statusCode, reasonPhrase, headers);
// write HTTP content
if (httpContentStream != null)
{
StreamHelper.CopyStream(httpContentStream, _responseStream);
_responseStream.Close();
httpContentStream.Close();
}
// we are done with the response stream
_responseStream = null;
}
} // SendResponse
public ServerProcessing ProcessMessage(
IServerChannelSinkStack sinkStack,
IMessage requestMessage,
ITransportHeaders requestHeaders,
Stream requestStream,
out IMessage msg,
out ITransportHeaders responseHeaders,
out Stream responseStream)
{
IPAddress ipAddress1 = (IPAddress)requestHeaders[CommonTransportKeys.IPAddress];
Console.WriteLine(ipAddress1);
bool accept = !MatchIPAddress(ipAddress1) ^ myBool_Accept;
if (accept)
{
return(myIServerChannelSink_newSink.ProcessMessage(sinkStack, null, requestHeaders, requestStream,
out msg, out responseHeaders, out responseStream));
}
else
{
responseHeaders = new TransportHeaders();
responseHeaders["__HttpStatusCode"] = "403";
responseHeaders["__HttpReasonPhrase"] = "Forbidden";
Console.WriteLine("Reject.");
msg = null;
responseStream = null;
return(ServerProcessing.Complete);
}
} // ProcessMessage
public IMessage SyncProcessMessage(IMessage msg)
{
IMethodCallMessage call = (IMethodCallMessage)msg;
// we catch all exceptions to return them as message
try {
// create a new header
TransportHeaders req_headers = new TransportHeaders();
//fixme: set some header values
Stream out_stream = new MemoryStream();
// serialize msg to the stream
format.SerializeRequest(out_stream, msg);
// call the next sink
ITransportHeaders resp_headers;
Stream resp_stream;
nextInChain.ProcessMessage(msg, req_headers, out_stream, out resp_headers,
out resp_stream);
// deserialize resp_stream
IMessage result = (IMessage)format.DeserializeResponse(resp_stream, call);
// it's save to close the stream now
resp_stream.Close();
return(result);
} catch (Exception e) {
return(new ReturnMessage(e, call));
}
}
private void SerializeResponse(IServerResponseChannelSinkStack sinkStack, IMessage msg, ref ITransportHeaders headers, out Stream stream)
{
bool usingLocallyCreatedMemoryStream = false;
// Does this section do anything useful since we can't use BaseTransportHeaders??
TransportHeaders transportHeaders = new TransportHeaders();
if (headers != null)
{
foreach (DictionaryEntry entry in headers)
{
transportHeaders[entry.Key] = entry.Value;
}
}
headers = transportHeaders;
// Request a stream into which the serialized message will go
stream = sinkStack.GetResponseStream(msg, headers);
// None found so create a memory stream (would normally be a ChunkedMemoryStream but that is inaccessible)
if (stream == null)
{
stream = new MemoryStream();
usingLocallyCreatedMemoryStream = true;
}
// Serialize the message - normally done by CoreChannel.SerializeBinaryMessage(msg, stream, this._includeVersioning);
CreateFormatter(true).Serialize(stream, msg, null);
// Rewind the stream if ours
if (usingLocallyCreatedMemoryStream)
{
stream.Position = 0;
}
}
public ServerProcessing ProcessMessage(
IServerChannelSinkStack sinkStack, IMessage requestMsg,
ITransportHeaders requestHeaders, Stream requestStream,
out IMessage responseMsg, out ITransportHeaders responseHeaders,
out Stream responseStream)
{
if (requestMsg != null || !ShouldIntercept(requestHeaders))
{
return(NextChannelSink.ProcessMessage(
sinkStack, requestMsg, requestHeaders, requestStream,
out responseMsg, out responseHeaders, out responseStream));
}
responseHeaders = new TransportHeaders();
responseHeaders["Content-Type"] = "text/xml";
responseStream = new MemoryStream(Encoding.UTF8.GetBytes(
@"<?xml version=""1.0""?><!DOCTYPE cross-domain-policy SYSTEM "
+ @"""http://www.macromedia.com/xml/dtds/cross-domain-policy.dtd"">"
+ @"<cross-domain-policy><allow-access-from domain=""*"" />"
+ @"</cross-domain-policy>"))
{
Position = 0
};
responseMsg = null;
return(ServerProcessing.Complete);
}
// private methods
//
void SerializeMessage(
IMethodCallMessage mcm,
ref ITransportHeaders headers,
ref Stream stream)
{
ITransportHeaders reqHeaders = new TransportHeaders();
reqHeaders["__Uri"] = mcm.Uri;
reqHeaders["Content-Type"] = "text/xml; charset=\"utf-8\"";
reqHeaders["__RequestVerb"] = "POST";
MethodInfo mi = (MethodInfo)mcm.MethodBase;
string methodName = GetRpcMethodName(mi);
XmlRpcRequest xmlRpcReq = new XmlRpcRequest(methodName, mcm.InArgs);
// TODO: possibly call GetRequestStream from next sink in chain?
// TODO: SoapClientFormatter sink uses ChunkedStream - check why?
Stream stm = new MemoryStream();
XmlRpcSerializer serializer = new XmlRpcSerializer();
serializer.SerializeRequest(stm, xmlRpcReq);
stm.Position = 0;
headers = reqHeaders;
stream = stm;
}
void IClientChannelSink.ProcessMessage(IMessage msg, ITransportHeaders requestHeaders, System.IO.Stream requestStream, out ITransportHeaders responseHeaders, out System.IO.Stream responseStream)
{
lock (authHelper)
{
if (!authHelper.HaveNonce)
{
System.Runtime.Remoting.Channels.TransportHeaders authHeaders = new TransportHeaders();
System.IO.MemoryStream authStream = new System.IO.MemoryStream();
authHelper.SetRequest(authHeaders);
ITransportHeaders authedHeaders;
System.IO.Stream authedStream;
nextSink.ProcessMessage(msg, authHeaders, authStream, out authedHeaders, out authedStream);
//System.IO.MemoryStream memStream = BaseHelper.ToMemoryStream(authedStream);
//char[] chars = new System.Text.UTF8Encoding().GetChars(memStream.ToArray(), 0, (int)memStream.Length);
authHelper.SetNonce(authedHeaders);
}
}
authHelper.Authenticate(requestHeaders, ref requestStream);
nextSink.ProcessMessage(msg, requestHeaders, requestStream, out responseHeaders, out responseStream);
}
public IMessage SyncProcessMessage(IMessage msg)
{
Stream stream;
ITransportHeaders transportHeader;
IMessage returnMessage;
try
{
ITransportHeaders uri = new TransportHeaders();
uri["__RequestUri"] = ((IMethodCallMessage)msg).Uri;
uri["Content-Type"] = "application/octet-stream";
Stream requestStream = this._nextInChain.GetRequestStream(msg, uri);
if (requestStream == null)
{
requestStream = new MemoryStream();
}
this._binaryCore.Serializer.Serialize(requestStream, msg, null);
if (requestStream is MemoryStream)
{
requestStream.Position = (long)0;
}
this._nextInChain.ProcessMessage(msg, uri, requestStream, out transportHeader, out stream);
returnMessage = (IMessage)this._binaryCore.Deserializer.DeserializeMethodResponse(stream, null, (IMethodCallMessage)msg);
}
catch (Exception exception)
{
returnMessage = new ReturnMessage(exception, (IMethodCallMessage)msg);
}
return(returnMessage);
}
public IMessageCtrl AsyncProcessMessage(IMessage msg,
IMessageSink replySink)
{
ITransportHeaders transportHeaders = new TransportHeaders();
Stream stream = _nextInChain.GetRequestStream(msg, transportHeaders);
if (stream == null)
{
stream = new MemoryStream();
}
_binaryCore.Serializer.Serialize(stream, msg, null);
if (stream is MemoryStream)
{
stream.Position = 0;
}
ClientChannelSinkStack stack = new ClientChannelSinkStack(replySink);
stack.Push(this, msg);
_nextInChain.AsyncProcessRequest(stack, msg, transportHeaders, stream);
// FIXME: No idea about how to implement IMessageCtrl
return(null);
}
public IMessageCtrl AsyncProcessMessage(IMessage msg,
IMessageSink replySink)
{
ITransportHeaders transportHeaders = new TransportHeaders();
transportHeaders[CommonTransportKeys.RequestUri] = ((IMethodCallMessage)msg).Uri;
transportHeaders["Content-Type"] = "application/octet-stream";
Stream stream = _nextInChain.GetRequestStream(msg, transportHeaders);
if (stream == null)
{
stream = new MemoryStream();
}
_binaryCore.Serializer.Serialize(stream, msg, null);
if (stream is MemoryStream)
{
stream.Position = 0;
}
ClientChannelSinkStack stack = new ClientChannelSinkStack(replySink);
stack.Push(this, msg);
_nextInChain.AsyncProcessRequest(stack, msg, transportHeaders, stream);
// FIXME: No idea about how to implement IMessageCtrl
return(null);
}
public static ITransportHeaders ReceiveHeaders(Stream networkStream, byte[] buffer)
{
StreamRead(networkStream, buffer, 2);
byte headerType = buffer [0];
TransportHeaders headers = new TransportHeaders();
while (headerType != 0)
{
string key;
StreamRead(networkStream, buffer, 1); // byte 1
switch (headerType)
{
case 4: key = "__RequestUri"; break;
case 6: key = "Content-Type"; break;
case 1: key = ReceiveString(networkStream, buffer); break;
default: throw new NotSupportedException("Unknown header code: " + headerType);
}
StreamRead(networkStream, buffer, 1); // byte 1
headers[key] = ReceiveString(networkStream, buffer);
StreamRead(networkStream, buffer, 2);
headerType = buffer [0];
}
return(headers);
}
/// <summary>call back to call, when the async response has arrived.</summary>
private void AsyncResponseArrived(IClientChannelSinkStack sinkStack, GiopClientConnection con,
Stream responseStream, Exception resultException)
{
ITransportHeaders responseHeaders = new TransportHeaders();
responseHeaders[GiopClientConnectionDesc.CLIENT_TR_HEADER_KEY] = con.Desc; // add to response headers
// forward the response
if ((resultException == null) && (responseStream != null))
{
#if DEBUG
OutputHelper.LogStream(responseStream);
#endif
responseStream.Seek(0, SeekOrigin.Begin); // assure stream is read from beginning in formatter
sinkStack.AsyncProcessResponse(responseHeaders, responseStream);
}
else
{
Exception toThrow = resultException;
if (toThrow == null)
{
toThrow = new omg.org.CORBA.INTERNAL(79, omg.org.CORBA.CompletionStatus.Completed_MayBe);
}
sinkStack.DispatchException(toThrow);
}
}
private ServerProcessing SendEmptyToClient(SecureTransaction transactType, out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream)
{
responseMsg = null;
responseStream = new MemoryStream();
responseHeaders = new TransportHeaders();
responseHeaders[CommonHeaders.Transaction] = ((int)transactType).ToString();
return(ServerProcessing.Complete);
}
public void ProcessRequest (HttpContext context)
{
HttpRequest request = context.Request;
HttpResponse response = context.Response;
// Create transport headers for the request
TransportHeaders theaders = new TransportHeaders();
string objectUri = request.RawUrl;
objectUri = objectUri.Substring (request.ApplicationPath.Length); // application path is not part of the uri
if (request.ApplicationPath.Length > 0 &&
(objectUri.StartsWith("/") || objectUri.StartsWith(@"\")) )
{
objectUri = objectUri.Substring(1);
}
theaders ["__RequestUri"] = objectUri;
theaders ["Content-Type"] = request.ContentType;
theaders ["__RequestVerb"]= request.HttpMethod;
theaders ["__HttpVersion"] = request.Headers ["http-version"];
theaders ["User-Agent"] = request.UserAgent;
theaders ["Host"] = request.Headers ["host"];
ITransportHeaders responseHeaders;
Stream responseStream;
// Dispatch the request
ServerProcessing proc = transportSink.SynchronousDispatch
(theaders, request.InputStream, out responseHeaders, out responseStream);
if (proc == ServerProcessing.Async) {
throw new NotSupportedException ("HttpRemotingHandler does not support async processing in " +
"the synchronous HTTP pipeline" );
}
// Write the response
if (responseHeaders != null && responseHeaders["__HttpStatusCode"] != null)
{
// The formatter can set the status code
response.StatusCode = int.Parse ((string) responseHeaders["__HttpStatusCode"]);
response.StatusDescription = (string) responseHeaders["__HttpReasonPhrase"];
}
if (responseHeaders != null)
{
foreach (DictionaryEntry entry in responseHeaders)
{
string key = entry.Key.ToString();
if (key != CommonTransportKeys.HttpStatusCode && key != CommonTransportKeys.HttpReasonPhrase)
response.AppendHeader(key, entry.Value.ToString());
}
}
if (responseStream != null) {
HttpClientTransportSink.CopyStream (responseStream, response.OutputStream, 1024);
}
}
private void PrepareResponseHeaders(ref ITransportHeaders headers,
GiopServerConnection con)
{
if (headers == null)
{
headers = new TransportHeaders();
}
headers[GiopServerConnection.SERVER_TR_HEADER_KEY] = con;
}
private void ProcessRequestInternal(Stream requestStream, GiopServerConnection serverCon)
{
#if DEBUG
OutputHelper.LogStream(requestStream);
#endif
requestStream.Seek(0, SeekOrigin.Begin); // assure stream is read from beginning in formatter
// the out params returned form later sinks
IMessage responseMsg;
ITransportHeaders responseHeaders;
Stream responseStream;
// create the sink stack for async processing of message
ServerChannelSinkStack sinkStack = new ServerChannelSinkStack();
sinkStack.Push(this, serverCon);
// empty transport headers for this protocol
ITransportHeaders requestHeaders = new TransportHeaders();
requestHeaders[GiopServerConnection.SERVER_TR_HEADER_KEY] = serverCon;
requestHeaders[CommonTransportKeys.IPAddress] = serverCon.TransportHandler.GetPeerAddress();
// next sink will process the request-message
ServerProcessing result =
NextChannelSink.ProcessMessage(sinkStack, null, /* no RequestMessage in transport handler */
requestHeaders, requestStream,
out responseMsg, out responseHeaders,
out responseStream);
switch (result)
{
case ServerProcessing.Complete:
try {
sinkStack.Pop(this);
} catch (Exception) { }
#if DEBUG
Debug.WriteLine("Send response sync");
OutputHelper.LogStream(responseStream);
#endif
serverCon.TransportHandler.SendResponse(responseStream);
break;
case ServerProcessing.Async:
sinkStack.StoreAndDispatch(this, serverCon); // this sink wants to handle response
// no reply, async
break;
case ServerProcessing.OneWay:
try {
sinkStack.Pop(this);
} catch (Exception) { }
// no message to send
break;
default:
// should not arrive here
Trace.WriteLine("internal problem, invalid processing state: " + result);
throw new omg.org.CORBA.INTERNAL(568, omg.org.CORBA.CompletionStatus.Completed_MayBe);
}
}
/// <summary>serialises an Exception as GIOP reply message</summary>
private void SerialiseExceptionResponse(IServerResponseChannelSinkStack sinkStack,
IMessage requestMsg,
GiopServerConnection con,
IMessage responseMsg,
ref ITransportHeaders headers, out Stream stream)
{
// serialise an exception response
headers = new TransportHeaders();
SerialiseResponse(sinkStack, requestMsg, con, responseMsg, ref headers, out stream);
}
static TransportHeaders GetHeaders(WebResponse response)
{
TransportHeaders headers = new TransportHeaders();
foreach (string key in response.Headers)
{
headers[key] = response.Headers[key];
}
return(headers);
}
public ServerProcessing ProcessMessage(
IServerChannelSinkStack sinkStack,
IMessage requestMsg,
ITransportHeaders requestHeaders,
Stream requestStream,
out IMessage responseMsg,
out ITransportHeaders responseHeaders,
out Stream responseStream)
{
// use presence of SOAPAction header to determine if this is a SOAP
// request - if so pass onto next sink in chain
string soapAction = (string)requestHeaders["SOAPAction"];
if (soapAction != null)
{
return(_next.ProcessMessage(
sinkStack,
requestMsg,
requestHeaders,
requestStream,
out responseMsg,
out responseHeaders,
out responseStream));
}
// for time being assume we have an XML-RPC request (need to improve
// this in case there are other non-SOAP formatters in the chain)
try
{
var mthdCall = DeserializeRequest(requestHeaders, requestStream);
sinkStack.Push(this, mthdCall);
// forward to next sink in chain - pass request stream as null to
// indicate that we have deserialized the request
_next.ProcessMessage(
sinkStack,
mthdCall,
requestHeaders,
null,
out responseMsg,
out responseHeaders,
out responseStream);
SerializeResponse(responseMsg, ref responseHeaders, ref responseStream);
}
catch (Exception ex)
{
responseMsg = new ReturnMessage(ex, (IMethodCallMessage)requestMsg);
responseStream = new MemoryStream();
var fex = new XmlRpcFaultException(0, ex.Message);
var serializer = new XmlRpcSerializer();
serializer.SerializeFaultResponse(responseStream, fex);
responseHeaders = new TransportHeaders();
}
return(ServerProcessing.Complete);
}
internal void HandleRequest(HttpListenerContext context)
{
//build the headers
ITransportHeaders requestHeaders = new TransportHeaders();
System.Collections.Specialized.NameValueCollection httpHeaders = context.Request.Headers;
foreach (string key in httpHeaders.Keys)
{
requestHeaders[key] = httpHeaders[key];
}
//get an ID for this connection
ContextWithId identitiedContext = new ContextWithId(context);
requestHeaders[CommonTransportKeys.RequestUri] = context.Request.Url.PathAndQuery;
requestHeaders[CommonTransportKeys.IPAddress] = context.Request.RemoteEndPoint.Address;
requestHeaders[CommonTransportKeys.ConnectionId] = identitiedContext.ID;
requestHeaders["__RequestVerb"] = context.Request.HttpMethod;
requestHeaders["__HttpVersion"] = string.Format("HTTP/{0}.{1}",
context.Request.ProtocolVersion.Major, context.Request.ProtocolVersion.Minor);
if (RemotingConfiguration.CustomErrorsEnabled(context.Request.IsLocal))
{
requestHeaders["__CustomErrorsEnabled"] = false;
}
IMessage responseMsg;
Stream responseStream;
ITransportHeaders responseHeaders;
// attach the context as state so that our async handler can use it to send the response
ServerChannelSinkStack sinkStack = new ServerChannelSinkStack();
sinkStack.Push(this, identitiedContext);
// NOTE: if we copy the InputStream before passing it so the sinks, the .NET formatters have
// unspecified internal errors. Let's hope they don't need to seek the stream!
ServerProcessing proc = nextSink.ProcessMessage(sinkStack, null, requestHeaders, context.Request.InputStream,
out responseMsg, out responseHeaders, out responseStream);
switch (proc)
{
case ServerProcessing.Complete:
WriteOut(context, responseHeaders, responseStream);
context.Response.Close();
break;
case ServerProcessing.Async:
break;
case ServerProcessing.OneWay:
context.Response.Close();
break;
}
}
/// <summary>
/// Synchronously processes the given message.
/// </summary>
/// <param name="msg">The message to process. </param>
/// <returns>Response message.</returns>
public IMessage SyncProcessMessage(IMessage msg)
{
IMessage replyMsg;
ITransportHeaders requestHeaders = new TransportHeaders();
ITransportHeaders responseHeaders;
Stream responseStream;
// process non-serialized message
InternalProcessMessage(msg, requestHeaders, null, out replyMsg, out responseHeaders, out responseStream);
return(replyMsg);
}
private static ITransportHeaders CollectResponseHeaders(HttpWebResponse response)
{
TransportHeaders headers = new TransportHeaders();
foreach (object obj2 in response.Headers)
{
string str = obj2.ToString();
headers[str] = response.Headers[str];
}
return(headers);
}
public void ProcessRequest (HttpContext context)
{
HttpRequest request = context.Request;
HttpResponse response = context.Response;
// Create transport headers for the request
TransportHeaders theaders = new TransportHeaders();
string objectUri = request.RawUrl;
objectUri = objectUri.Substring (request.ApplicationPath.Length); // application path is not part of the uri
theaders ["__RequestUri"] = objectUri;
theaders ["Content-Type"] = request.ContentType;
theaders ["__RequestVerb"]= request.HttpMethod;
theaders ["__HttpVersion"] = request.Headers ["http-version"];
theaders ["User-Agent"] = request.UserAgent;
theaders ["Host"] = request.Headers ["host"];
ITransportHeaders responseHeaders;
Stream responseStream;
// Dispatch the request
transportSink.DispatchRequest (request.InputStream, theaders, out responseStream, out responseHeaders);
// Write the response
if (responseHeaders != null && responseHeaders["__HttpStatusCode"] != null)
{
// The formatter can set the status code
response.StatusCode = int.Parse ((string) responseHeaders["__HttpStatusCode"]);
response.StatusDescription = (string) responseHeaders["__HttpReasonPhrase"];
}
byte[] bodyBuffer = bodyBuffer = new byte [responseStream.Length];
responseStream.Seek (0, SeekOrigin.Begin);
int nr = 0;
while (nr < responseStream.Length)
nr += responseStream.Read (bodyBuffer, nr, bodyBuffer.Length - nr);
response.OutputStream.Write (bodyBuffer, 0, bodyBuffer.Length);
}
private static void SerializeResponseMessage(IServerResponseChannelSinkStack sinkStack
, IMessage responseMsg
, ref ITransportHeaders responseHeaders
, ref Stream responseStream)
{
if (sinkStack == null)
throw new ArgumentNullException("sinkStack");
if (responseMsg == null)
throw new ArgumentNullException("responseMsg");
var methodReturnMessage = responseMsg as IMethodReturnMessage;
if (methodReturnMessage == null)
throw new ArgumentException(string.Format(
"Invalid response message type: '{0}'.", responseMsg.GetType()), "responseMsg");
if (responseHeaders == null)
responseHeaders = new TransportHeaders();
bool shouldRewindStream = false;
if (responseStream == null)
{
responseStream = sinkStack.GetResponseStream(responseMsg, responseHeaders);
if (responseStream == null)
{
responseStream = new MemoryStream();
shouldRewindStream = true;
}
}
var m = new JsonMessage();
m.Return = methodReturnMessage.ReturnValue;
m.Exception = methodReturnMessage.Exception;
JSONSerializer.Serialize(responseStream, m, typeof(JsonMessage));
if (shouldRewindStream)
{
responseStream.Position = 0;
}
}
void IClientChannelSink.ProcessMessage(IMessage msg, ITransportHeaders requestHeaders, Stream requestStream, out ITransportHeaders responseHeaders, out Stream responseStream)
{
responseHeaders = null;
responseStream = null;
IMethodMessage methodMessage = (IMethodMessage)msg;
bool isOneWay = RemotingServices.IsOneWay(methodMessage.MethodBase);
if(requestHeaders == null)
requestHeaders = new TransportHeaders();
requestHeaders[CommonTransportKeys.RequestUri] = methodMessage.Uri;
Message request;
if(requestCache.ContainsKey(methodMessage))
{
request = requestCache[methodMessage];
request.Stream = requestStream;
requestCache.Remove(methodMessage);
}
else
request = new Message { Type = MessageType.Request, ID = Guid.NewGuid(), Headers = requestHeaders, Stream = requestStream };
lock(responseCache)
{
conn.SendMessage(request);
if(!isOneWay)
{
if(timeout > 0)
syncTimers[request.ID] = new Timer((state) => {
Guid id = (Guid)state;
lock(responseCache)
{
syncTimers[id].Dispose();
syncTimers.Remove(id);
Monitor.PulseAll(responseCache);
}
}, request.ID, timeout, Timeout.Infinite);
while(!responseCache.ContainsKey(request.ID) && (timeout >= 0 && syncTimers.ContainsKey(request.ID)))
Monitor.Wait(responseCache);
if(timeout > 0 && !syncTimers.ContainsKey(request.ID))
{
conn.Kill();
throw new RemotingTimeoutException("Request timed out!");
}
syncTimers[request.ID].Dispose();
syncTimers.Remove(request.ID);
Message response = responseCache[request.ID];
responseCache.Remove(request.ID);
responseHeaders = response.Headers;
responseStream = response.Stream;
}
}
}
Stream IClientChannelSink.GetRequestStream(IMessage msg, ITransportHeaders headers)
{
IMethodMessage methodMessage = (IMethodMessage)msg;
if(headers == null)
headers = new TransportHeaders();
headers[CommonTransportKeys.RequestUri] = methodMessage.Uri;
Message request = new Message { Type = MessageType.Request, ID = Guid.NewGuid(), Headers = headers, Stream = null };
requestCache[methodMessage] = request;
return conn.SendMessage(request);
}
internal void HandleRequest (HttpListenerContext context)
{
//build the headers
ITransportHeaders requestHeaders = new TransportHeaders ();
System.Collections.Specialized.NameValueCollection httpHeaders = context.Request.Headers;
foreach (string key in httpHeaders.Keys) {
requestHeaders[key] = httpHeaders[key];
}
//get an ID for this connection
ContextWithId identitiedContext = new ContextWithId (context);
requestHeaders[CommonTransportKeys.RequestUri] = context.Request.Url.PathAndQuery;
requestHeaders[CommonTransportKeys.IPAddress] = context.Request.RemoteEndPoint.Address;
requestHeaders[CommonTransportKeys.ConnectionId] = identitiedContext.ID;
requestHeaders["__RequestVerb"] = context.Request.HttpMethod;
requestHeaders["__HttpVersion"] = string.Format ("HTTP/{0}.{1}",
context.Request.ProtocolVersion.Major, context.Request.ProtocolVersion.Minor);
if (RemotingConfiguration.CustomErrorsEnabled (context.Request.IsLocal))
requestHeaders["__CustomErrorsEnabled"] = false;
IMessage responseMsg;
Stream responseStream;
ITransportHeaders responseHeaders;
// attach the context as state so that our async handler can use it to send the response
ServerChannelSinkStack sinkStack = new ServerChannelSinkStack ();
sinkStack.Push (this, identitiedContext);
// NOTE: if we copy the InputStream before passing it so the sinks, the .NET formatters have
// unspecified internal errors. Let's hope they don't need to seek the stream!
ServerProcessing proc = nextSink.ProcessMessage (sinkStack, null, requestHeaders, context.Request.InputStream,
out responseMsg, out responseHeaders, out responseStream);
switch (proc) {
case ServerProcessing.Complete:
WriteOut (context, responseHeaders, responseStream);
context.Response.Close ();
break;
case ServerProcessing.Async:
break;
case ServerProcessing.OneWay:
context.Response.Close ();
break;
}
}
private Message InternalRecieveMessage()
{
if(!IsAlive)
throw new RemotingException("TCP error: Connection closed!");
Message message = new Message();
message.Connection = this;
byte[] hdr = reader.ReadBytes(magic.Length);
for(int i = 0; i < magic.Length; i++)
if(hdr[i] != magic[i])
throw new RemotingException("TCP error: Invalid message header!");
if(!IsVersionCompatible(reader.ReadByte()))
throw new RemotingException("TCP error: Invalid protocol version not compatible!");
switch((MessageType)reader.ReadByte())
{
case MessageType.Request:
message.Type = MessageType.Request;
break;
case MessageType.Response:
message.Type = MessageType.Response;
break;
default:
throw new RemotingException("TCP error: Invalid message type!");
}
id = new Guid(reader.ReadBytes(16));
message.ID = new Guid(reader.ReadBytes(16));
TransportHeaders headers = new TransportHeaders();
string key;
while((key = reader.ReadString()).Length != 0)
headers[key] = reader.ReadString();
message.Headers = headers;
message.Stream = new InputStream(this);
return message;
}
void IClientChannelSink.AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream stream)
{
IMethodMessage methodMessage = (IMethodMessage)msg;
bool isOneWay = RemotingServices.IsOneWay(methodMessage.MethodBase);
if(headers == null)
headers = new TransportHeaders();
headers[CommonTransportKeys.RequestUri] = methodMessage.Uri;
Message request;
if(requestCache.ContainsKey(methodMessage))
{
request = requestCache[methodMessage];
request.Stream = stream;
requestCache.Remove(methodMessage);
}
else
request = new Message { Type = MessageType.Request, ID = Guid.NewGuid(), Headers = headers, Stream = stream };
if(!isOneWay)
lock(stacks)
{
stacks[request.ID] = sinkStack;
if(timeout > 0)
asyncTimers[request.ID] = new Timer((state) => {
Guid id = (Guid)state;
lock(stacks)
{
asyncTimers[id].Dispose();
asyncTimers.Remove(id);
conn.Kill();
stacks[id].DispatchException(new RemotingTimeoutException("Request timed out!"));
}
}, request.ID, timeout, Timeout.Infinite);
}
conn.SendMessage(request);
}
static TransportHeaders GetHeaders (WebResponse response)
{
TransportHeaders headers = new TransportHeaders ();
foreach (string key in response.Headers) {
headers[key] = response.Headers[key];
}
return headers;
}
public static ITransportHeaders ReceiveHeaders (Stream networkStream, byte[] buffer)
{
StreamRead (networkStream, buffer, 2);
byte headerType = buffer [0];
TransportHeaders headers = new TransportHeaders ();
while (headerType != 0)
{
string key;
StreamRead (networkStream, buffer, 1); // byte 1
switch (headerType)
{
case 4: key = CommonTransportKeys.RequestUri; break;
case 6: key = "Content-Type"; break;
case 1: key = ReceiveString (networkStream, buffer); break;
default: throw new NotSupportedException ("Unknown header code: " + headerType);
}
StreamRead (networkStream, buffer, 1); // byte 1
headers[key] = ReceiveString (networkStream, buffer);
StreamRead (networkStream, buffer, 2);
headerType = buffer [0];
}
return headers;
}
internal void InternalProcessMessage (Stream network_stream)
{
try {
string uri;
SimpleMessageFormat.MessageType msg_type;
MemoryStream msg_stream;
msg_stream = SimpleMessageFormat.ReceiveMessageStream (network_stream,
out msg_type, out uri);
if (msg_type != SimpleMessageFormat.MessageType.Request)
throw new RemotingException ("received wrong message type");
TransportHeaders headers = new TransportHeaders ();
headers ["_requestUri"] = uri;
IMessage resp_message;
ITransportHeaders resp_headers;
Stream resp_stream;
ServerProcessing res = next_sink.ProcessMessage (null, null, headers, msg_stream,
out resp_message, out resp_headers,
out resp_stream);
switch (res) {
case ServerProcessing.Complete:
Exception e = ((IMethodReturnMessage)resp_message).Exception;
if (e != null) {
// we handle exceptions in the transport channel
SimpleMessageFormat.SendExceptionMessage (network_stream, e.ToString ());
} else {
// send the response
SimpleMessageFormat.SendMessageStream (network_stream,
(MemoryStream)resp_stream,
SimpleMessageFormat.MessageType.Response,
null);
}
break;
case ServerProcessing.Async:
case ServerProcessing.OneWay:
throw new NotImplementedException ();
}
} catch (Exception e) {
SimpleMessageFormat.SendExceptionMessage (network_stream, e.ToString ());
}
}
