internal void ServiceRequest(object state)
{
IMessage message;
ITransportHeaders headers2;
Stream stream2;
HttpServerSocketHandler handler = (HttpServerSocketHandler) state;
ITransportHeaders requestHeaders = handler.ReadHeaders();
Stream requestStream = handler.GetRequestStream();
requestHeaders["__CustomErrorsEnabled"] = handler.CustomErrorsEnabled();
ServerChannelSinkStack sinkStack = new ServerChannelSinkStack();
sinkStack.Push(this, handler);
ServerProcessing processing = this._nextSink.ProcessMessage(sinkStack, null, requestHeaders, requestStream, out message, out headers2, out stream2);
switch (processing)
{
case ServerProcessing.Complete:
sinkStack.Pop(this);
handler.SendResponse(stream2, "200", "OK", headers2);
break;
case ServerProcessing.OneWay:
handler.SendResponse(null, "202", "Accepted", headers2);
break;
case ServerProcessing.Async:
sinkStack.StoreAndDispatch(this, handler);
break;
}
if (processing != ServerProcessing.Async)
{
if (handler.CanServiceAnotherRequest())
{
handler.BeginReadMessage();
}
else
{
handler.Close();
}
}
}
public void HandleRequest(HttpContext context)
{
IMessage message;
ITransportHeaders headers2;
Stream stream2;
HttpRequest request = context.Request;
HttpResponse httpResponse = context.Response;
BaseTransportHeaders requestHeaders = new BaseTransportHeaders();
requestHeaders["__RequestVerb"] = request.HttpMethod;
requestHeaders["__CustomErrorsEnabled"] = HttpRemotingHandler.CustomErrorsEnabled(context);
requestHeaders.RequestUri = (string) context.Items["__requestUri"];
NameValueCollection headers = request.Headers;
foreach (string str in headers.AllKeys)
{
string str2 = headers[str];
requestHeaders[str] = str2;
}
requestHeaders.IPAddress = IPAddress.Parse(request.UserHostAddress);
Stream inputStream = request.InputStream;
ServerChannelSinkStack sinkStack = new ServerChannelSinkStack();
sinkStack.Push(this, null);
switch (this._nextSink.ProcessMessage(sinkStack, null, requestHeaders, inputStream, out message, out headers2, out stream2))
{
case ServerProcessing.Complete:
this.SendResponse(httpResponse, 200, headers2, stream2);
return;
case ServerProcessing.OneWay:
this.SendResponse(httpResponse, 0xca, headers2, stream2);
break;
case ServerProcessing.Async:
break;
default:
return;
}
}
} // TcpServerTransportSink
internal void ServiceRequest(Object state)
{
TcpServerSocketHandler streamManager = (TcpServerSocketHandler)state;
ITransportHeaders headers = streamManager.ReadHeaders();
Stream requestStream = streamManager.GetRequestStream();
RemotingServices.LogRemotingStage(CoreChannel.SERVER_MSG_RECEIVE);
// process request
ServerChannelSinkStack sinkStack = new ServerChannelSinkStack();
sinkStack.Push(this, streamManager);
IMessage responseMessage;
ITransportHeaders responseHeaders;
Stream responseStream;
ServerProcessing processing =
_nextSink.ProcessMessage(sinkStack, null, headers, requestStream,
out responseMessage,
out responseHeaders, out responseStream);
// handle response
switch (processing)
{
case ServerProcessing.Complete:
{
// Send the response. Call completed synchronously.
sinkStack.Pop(this);
RemotingServices.LogRemotingStage(CoreChannel.SERVER_RET_END);
streamManager.SendResponse(responseHeaders, responseStream);
break;
} // case ServerProcessing.Complete
case ServerProcessing.OneWay:
{
// No response needed, but the following method will make sure that
// we send at least a skeleton reply if the incoming request was
// not marked OneWayRequest (client/server metadata could be out of
// sync).
streamManager.SendResponse(responseHeaders, responseStream);
break;
} // case ServerProcessing.OneWay
case ServerProcessing.Async:
{
sinkStack.StoreAndDispatch(this, streamManager);
break;
}// case ServerProcessing.Async
} // switch (processing)
// async processing will take care if handling this later
if (processing != ServerProcessing.Async)
{
if (streamManager.CanServiceAnotherRequest())
streamManager.BeginReadMessage();
else
streamManager.Close();
}
} // ServiceRequest
internal void ServiceRequest(object state)
{
IpcServerHandler handler = (IpcServerHandler) state;
ITransportHeaders requestHeaders = handler.ReadHeaders();
Stream requestStream = handler.GetRequestStream();
requestHeaders["__CustomErrorsEnabled"] = false;
ServerChannelSinkStack sinkStack = new ServerChannelSinkStack();
sinkStack.Push(this, handler);
IMessage responseMsg = null;
ITransportHeaders responseHeaders = null;
Stream responseStream = null;
WindowsIdentity current = null;
IPrincipal currentPrincipal = null;
bool flag = false;
bool flag2 = false;
ServerProcessing complete = ServerProcessing.Complete;
try
{
if (this._secure)
{
handler.Port.ImpersonateClient();
currentPrincipal = Thread.CurrentPrincipal;
flag2 = true;
flag = true;
current = WindowsIdentity.GetCurrent();
if (!this._impersonate)
{
NativePipe.RevertToSelf();
Thread.CurrentPrincipal = new GenericPrincipal(current, null);
flag = false;
}
else
{
if ((current.ImpersonationLevel != TokenImpersonationLevel.Impersonation) && (current.ImpersonationLevel != TokenImpersonationLevel.Delegation))
{
throw new RemotingException(CoreChannel.GetResourceString("Remoting_Ipc_TokenImpersonationFailure"));
}
Thread.CurrentPrincipal = new WindowsPrincipal(current);
}
}
complete = this._nextSink.ProcessMessage(sinkStack, null, requestHeaders, requestStream, out responseMsg, out responseHeaders, out responseStream);
}
catch (Exception exception)
{
handler.CloseOnFatalError(exception);
}
finally
{
if (flag2)
{
Thread.CurrentPrincipal = currentPrincipal;
}
if (flag)
{
NativePipe.RevertToSelf();
flag = false;
}
}
switch (complete)
{
case ServerProcessing.Complete:
sinkStack.Pop(this);
handler.SendResponse(responseHeaders, responseStream);
break;
case ServerProcessing.OneWay:
handler.SendResponse(responseHeaders, responseStream);
break;
case ServerProcessing.Async:
sinkStack.StoreAndDispatch(this, handler);
break;
}
if (complete != ServerProcessing.Async)
{
handler.BeginReadMessage();
}
}
} // IServerChannelSink
internal void ServiceRequest(Object state)
{
HttpServerSocketHandler streamManager = (HttpServerSocketHandler)state;
ITransportHeaders headers = streamManager.ReadHeaders();
Stream requestStream = streamManager.GetRequestStream();
headers["__CustomErrorsEnabled"] = streamManager.CustomErrorsEnabled();
// process request
ServerChannelSinkStack sinkStack = new ServerChannelSinkStack();
sinkStack.Push(this, streamManager);
IMessage responseMessage;
ITransportHeaders responseHeaders;
Stream responseStream;
ServerProcessing processing =
_nextSink.ProcessMessage(sinkStack, null, headers, requestStream,
out responseMessage,
out responseHeaders, out responseStream);
// handle response
switch (processing)
{
case ServerProcessing.Complete:
{
// Send the response. Call completed synchronously.
sinkStack.Pop(this);
streamManager.SendResponse(responseStream, "200", "OK", responseHeaders);
break;
} // case ServerProcessing.Complete
case ServerProcessing.OneWay:
{
// Just send back a 200 OK
streamManager.SendResponse(null, "202", "Accepted", responseHeaders);
break;
} // case ServerProcessing.OneWay
case ServerProcessing.Async:
{
sinkStack.StoreAndDispatch(this, streamManager);
break;
}// case ServerProcessing.Async
} // switch (processing)
// async processing will take care if handling this later
if (processing != ServerProcessing.Async)
{
if (streamManager.CanServiceAnotherRequest())
streamManager.BeginReadMessage();
else
streamManager.Close();
}
} // ServiceRequest
internal ServerProcessing DispatchRequest (Stream requestStream, ITransportHeaders headers, out Stream responseStream, out ITransportHeaders responseHeaders)
{
ServerChannelSinkStack sinkStack = new ServerChannelSinkStack();
IMessage responseMessage;
return _nextSink.ProcessMessage (sinkStack, null, headers, requestStream,
out responseMessage,
out responseHeaders, out responseStream);
}
public void ProcessRequest(IConnection connection)
{
// parameters validation
if (connection == null)
throw new ArgumentNullException("connection");
// receive request
ITransportHeaders requestHeaders;
Stream requestStream;
connection.ReceiveRequest(out requestHeaders, out requestStream);
// create sink stack for request processing
ServerChannelSinkStack sinkStack = new ServerChannelSinkStack();
sinkStack.Push(this, connection); // save connection as state
// process request
ServerProcessing processing;
IMethodReturnMessage methodReturn = null;
ITransportHeaders responseHeaders = null;
Stream responseStream = null;
try
{
// call next sink to dispatch method call
IMessage responseMsg;
processing = _nextSink.ProcessMessage(sinkStack,
null, requestHeaders, requestStream,
out responseMsg, out responseHeaders, out responseStream);
if (processing == ServerProcessing.Complete)
{
// response headers and stream can not be null at this point!
if (responseHeaders == null)
throw new ArgumentNullException("responseHeaders");
if (responseStream == null)
throw new ArgumentNullException("responseStream");
// check response
methodReturn = responseMsg as IMethodReturnMessage;
if (methodReturn == null)
throw new NotSupportedException();
}
}
catch (Exception ex)
{
processing = ServerProcessing.Complete;
methodReturn = new ReturnMessage(ex, null);
}
// handle response
switch (processing)
{
case ServerProcessing.Complete:
{
// call completed synchronously - send response
sinkStack.Pop(this);
connection.SendResponse(methodReturn, responseHeaders, responseStream);
break;
}
case ServerProcessing.OneWay:
{
// no response needed
sinkStack.Pop(this);
break;
}
case ServerProcessing.Async:
{
// call proceeded asynchronously
sinkStack.StoreAndDispatch(this, connection);
break;
}
default:
throw new NotSupportedException();
}
}
private void ProcessMessage(object waitCallbackState)
{
var requestMessage = (NullMessages.RequestMessage)waitCallbackState;
// replace full url with object url
var url = requestMessage.RequestHeaders[CommonTransportKeys.RequestUri].ToString();
string objectUri;
NullChannel.ParseUrl(url, out objectUri);
objectUri = objectUri ?? url;
requestMessage.RequestHeaders[CommonTransportKeys.RequestUri] = objectUri;
requestMessage.Message.Properties["__Uri"] = objectUri;
// add client address property for compatibility
var callContext = requestMessage.Message.Properties["__CallContext"] as LogicalCallContext;
callContext.SetData(ClientAddressSink.CallContextSlotName, IPAddress.Loopback);
IMessage responseMsg;
ITransportHeaders responseHeaders;
Stream responseStream;
// create sink stack to process request message
var stack = new ServerChannelSinkStack();
stack.Push(this, null);
// process request message
ServerProcessing serverProcessing;
if (NextChannelSink != null)
{
// full processing mode, with deserialization
serverProcessing = NextChannelSink.ProcessMessage(stack, null,
requestMessage.RequestHeaders, requestMessage.RequestStream,
out responseMsg, out responseHeaders, out responseStream);
}
else
{
// fast processing mode, bypassing deserialization
serverProcessing = ChannelServices.DispatchMessage(stack, requestMessage.Message, out responseMsg);
responseHeaders = null;
responseStream = null;
}
// send back the reply
switch (serverProcessing)
{
case ServerProcessing.Complete:
stack.Pop(this);
NullMessages.AddResponse(requestMessage, new NullMessages.ResponseMessage
{
Message = responseMsg,
ResponseHeaders = responseHeaders,
ResponseStream = responseStream
});
break;
case ServerProcessing.Async:
stack.StoreAndDispatch(NextChannelSink, null);
break;
case ServerProcessing.OneWay:
stack.Pop(this);
break;
}
}
internal void ServiceRequest(Object state)
{
IpcServerHandler ipcServerHandler = (IpcServerHandler)state;
// Read the headers from the stream, using the header size in the message
ITransportHeaders headers = ipcServerHandler.ReadHeaders();
// Get the request Stream
Stream requestStream = ipcServerHandler.GetRequestStream();
// customErrors should be disabled, since we are on the same machine
headers["__CustomErrorsEnabled"] = false;
// process request
ServerChannelSinkStack sinkStack = new ServerChannelSinkStack();
sinkStack.Push(this, ipcServerHandler);
IMessage responseMessage = null;
ITransportHeaders responseHeaders = null;
Stream responseStream = null;
WindowsIdentity identity = null;
IPrincipal oldPrincipal = null;
bool impersonated = false;
bool principalChanged = false;
ServerProcessing processing = ServerProcessing.Complete;
try{
if (_secure)
{
IpcPort port = ipcServerHandler.Port;
port.ImpersonateClient();
oldPrincipal = Thread.CurrentPrincipal;
principalChanged = true;
impersonated = true;
identity = WindowsIdentity.GetCurrent();
// If the authentication mode is to identify callers only revert the impersonation immediately
if (!_impersonate)
{
NativePipe.RevertToSelf();
Thread.CurrentPrincipal = new GenericPrincipal(identity, null);
impersonated = false;
}
else
{
if (identity.ImpersonationLevel == TokenImpersonationLevel.Impersonation ||
identity.ImpersonationLevel == TokenImpersonationLevel.Delegation)
{
// Set the current principal
Thread.CurrentPrincipal = new WindowsPrincipal(identity);
}
else
throw new RemotingException(CoreChannel.GetResourceString(
"Remoting_Ipc_TokenImpersonationFailure"));
}
}
processing =
_nextSink.ProcessMessage(sinkStack, null, headers, requestStream,
out responseMessage,
out responseHeaders, out responseStream);
}
catch( Exception e) {
ipcServerHandler.CloseOnFatalError(e);
}
finally{
// Revert the principal if we had changed the principal
if (principalChanged)
{
Thread.CurrentPrincipal = oldPrincipal;
}
// Revert the impersonation if we had impersonated
if (impersonated)
{
NativePipe.RevertToSelf();
impersonated = false;
}
}
// handle response
switch (processing)
{
case ServerProcessing.Complete:
{
// Send the response. Call completed synchronously.
sinkStack.Pop(this);
// Send the response back to the client
ipcServerHandler.SendResponse(responseHeaders, responseStream);
break;
} // case ServerProcessing.Complete
case ServerProcessing.OneWay:
{
// No response needed, but the following method will make sure that
// we send at least a skeleton reply if the incoming request was
// not marked OneWayRequest (client/server metadata could be out of
// [....]).
ipcServerHandler.SendResponse(responseHeaders, responseStream);
break;
} // case ServerProcessing.OneWay
case ServerProcessing.Async:
{
sinkStack.StoreAndDispatch(this, ipcServerHandler);
break;
}// case ServerProcessing.Async
} // switch (processing)
// Start waiting for the next request
if (processing != ServerProcessing.Async)
{
ipcServerHandler.BeginReadMessage();
}
} // ServiceRequest
/// <summary>
/// Handles incoming message (message, response or event).
/// </summary>
/// <param name="message">The message to handle.</param>
public void HandleIncomingMessage(Message message)
{
BinaryLogWriter binaryLogWriter = message.ITransportContext.BinaryLogWriter;
try
{
ServerChannelSinkStack stack = new ServerChannelSinkStack();
stack.Push(this, message);
ITransportHeaders responseHeaders;
Stream responseStream;
IMessage responseMsg;
// FIX: 2.5.8 removing the application name from the object URI
string applicationName = RemotingConfiguration.ApplicationName;
if (applicationName != null)
{
string uri = (string) message.ITransportHeaders["__RequestUri"];
if (uri.Length > applicationName.Length && uri.StartsWith(applicationName))
{
int sizeToBeCut = applicationName.Length + (uri[applicationName.Length] == '/' ? 1 : 0);
uri = uri.Substring(sizeToBeCut);
message.ITransportHeaders["__RequestUri"] = uri;
}
}
message.ITransportHeaders["__CustomErrorsEnabled"] = false;
message.ITransportHeaders[CommonTransportKeys.IPAddress] = message.Sender.PhysicalAddress is IPEndPoint ? ((IPEndPoint) message.Sender.PhysicalAddress).Address : message.Sender.PhysicalAddress;
// LOG: put down the log record
if ( binaryLogWriter != null && binaryLogWriter[LogCategory.MessageProcessing] > 0 )
{
binaryLogWriter.WriteEvent(LogCategory.MessageProcessing, "GenuineUniversalServerTransportSink.HandleIncomingMessage",
LogMessageType.MessageRequestInvoking, null, message, message.Sender,
null,
GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name,
null, null, -1, GenuineUtility.TickCount, 0, 0, null, null, null, null,
"The .NET Remoting request is being invoked.");
}
ServerProcessing serverProcessing = this._nextChannelSink.ProcessMessage(stack, null, message.ITransportHeaders, message.Stream, out responseMsg, out responseHeaders, out responseStream);
switch (serverProcessing)
{
case ServerProcessing.Complete:
Message reply = new Message(message, responseHeaders, responseStream);
// LOG: put down the log record
if ( binaryLogWriter != null && binaryLogWriter[LogCategory.MessageProcessing] > 0 )
{
string invocationTarget = responseMsg.Properties["__Uri"] as string;
string methodName = BinaryLogWriter.ParseInvocationMethod(responseMsg.Properties["__MethodName"] as string, responseMsg.Properties["__TypeName"] as string);
binaryLogWriter.WriteMessageCreatedEvent("GenuineUniversalServerTransportSink.HandleIncomingMessage",
LogMessageType.MessageCreated, null, reply, false, reply.Recipient,
this.ITransportContext.BinaryLogWriter[LogCategory.MessageProcessing] > 1 ? reply.Stream : null,
invocationTarget, methodName,
GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name, null, -1, -1, null, -1, null,
"The response message has been created.");
reply.ITransportHeaders[Message.TransportHeadersInvocationTarget] = invocationTarget;
reply.ITransportHeaders[Message.TransportHeadersMethodName] = methodName;
binaryLogWriter.WriteEvent(LogCategory.MessageProcessing, "GenuineUniversalServerTransportSink.HandleIncomingMessage",
LogMessageType.MessageRequestInvoked, null, reply, message.Sender,
null,
GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name,
null, null, -1, GenuineUtility.TickCount, 0, message.SeqNo, null, null, null, null,
"The .NET Remoting invocation has been performed.");
}
message.ITransportContext.ConnectionManager.Send(reply);
break;
case ServerProcessing.Async:
// asyncProcessResponse will be called later
break;
case ServerProcessing.OneWay:
// LOG: put down the log record
if ( binaryLogWriter != null && binaryLogWriter[LogCategory.MessageProcessing] > 0 )
{
binaryLogWriter.WriteEvent(LogCategory.MessageProcessing, "GenuineUniversalServerTransportSink.HandleIncomingMessage",
LogMessageType.MessageRequestInvoked, null, null, message.Sender,
null,
GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name,
null, null, -1, GenuineUtility.TickCount, 0, message.SeqNo, null, null, null, null,
"One-way .NET Remoting invocation has been performed. No response is available.");
}
break;
}
}
catch(Exception ex)
{
try
{
// LOG: put down the log record
if ( binaryLogWriter != null && binaryLogWriter[LogCategory.MessageProcessing] > 0 )
{
binaryLogWriter.WriteEvent(LogCategory.MessageProcessing, "GenuineUniversalServerTransportSink.HandleIncomingMessage",
LogMessageType.MessageRequestInvoking, ex, message, message.Sender,
null,
GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name,
null, null, -1, 0, 0, 0, null, null, null, null,
"The .NET Remoting request resulted in exception. The exception is being sent back.");
}
// return this exception as a result
BinaryFormatter binaryFormatter = new BinaryFormatter();
GenuineChunkedStream serializedException = new GenuineChunkedStream(false);
binaryFormatter.Serialize(serializedException, ex);
Message reply = new Message(message, new TransportHeaders(), serializedException);
reply.ContainsSerializedException = true;
this.ITransportContext.ConnectionManager.Send(reply);
}
catch(Exception internalEx)
{
// It's a destiny not to deliver an exception back to the caller
// LOG: put down the log record
if ( binaryLogWriter != null && binaryLogWriter[LogCategory.MessageProcessing] > 0 )
{
binaryLogWriter.WriteEvent(LogCategory.MessageProcessing, "GenuineUniversalServerTransportSink.HandleIncomingMessage",
LogMessageType.MessageRequestInvoking, internalEx, message, message.Sender,
null,
GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name,
null, null, -1, 0, 0, 0, null, null, null, null,
"The source exception cannot be sent over the network. Both exceptions are ignored.");
}
}
}
}
private void ServerMain()
{
PipeConnection pipe = _pipe;
_pipe = null;
// Signal the guy to start waiting again... (w/ new event and endpoint)
_event.Set();
try
{
//TODO close the connection on a timeout
//TODO if no activity for Nnnn milliseconds
while (true)
{
pipe.BeginReadMessage();
ITransportHeaders headers = pipe.ReadHeaders();
headers["__CustomErrorsEnabled"] = false;
Stream request = pipe.ReadStream();
pipe.EndReadMessage();
ServerChannelSinkStack stack = new ServerChannelSinkStack();
stack.Push(_transportSink, null);
IMessage responseMsg;
ITransportHeaders responseHeaders;
Stream responseStream;
ServerProcessing processing = _transportSink.NextChannelSink.ProcessMessage(stack,
null,
headers,
request,
out responseMsg,
out responseHeaders,
out responseStream);
// handle response
switch (processing)
{
case ServerProcessing.Complete:
// Send the response. Call completed synchronously.
stack.Pop(_transportSink);
WriteClientResponse(pipe, responseHeaders, responseStream);
break;
case ServerProcessing.OneWay:
break;
case ServerProcessing.Async:
stack.StoreAndDispatch(_transportSink, null);
break;
}
}
}
catch (Exception e)
{
DBG.Info(null, "Terminating client connection: " + e.Message);
WriteExceptionResponse(pipe, e.ToString());
}
finally
{
if (pipe != null)
{
pipe.Dispose();
}
}
}
public void HandleIncomingMessage(ChannelMessage msg)
{
ITransportHeaders responseHeaders;
Stream responseStream;
IMessage responseMsg;
ServerChannelSinkStack stack = new ServerChannelSinkStack();
stack.Push(this,msg);
ServerProcessing proc = _nextSink.ProcessMessage(stack,null,msg.Headers,msg.Body,out responseMsg, out responseHeaders,out responseStream);
// check the return value.
switch (proc)
{
// this message has been handled synchronously
case ServerProcessing.Complete:
// send a response message
ChannelMessage reply = new ChannelMessage(msg.From,msg.ID,responseHeaders,responseStream);
ConnectionManager.SendMessage(reply);
break;
// this message has been handled asynchronously
case ServerProcessing.Async:
// nothing needs to be done yet
break;
// it's been a one way message
case ServerProcessing.OneWay:
// nothing needs to be done yet
break;
}
}
private IMessage MessageDispatcher(IMessage iMsgReq, Stream requestStream)
{
IMessage iMsgRsp = null;
if(iMsgReq.Properties["__Uri"] != null)
{
// parse url address
string strObjectUrl = iMsgReq.Properties["__Uri"].ToString();
string[] urlpath = strObjectUrl.Split(';');
string[] s = urlpath[0].Split('/');
// check endpoint
if(urlpath.Length == 1 && s.Length == 1)
{
//this is an end channel
Trace.WriteLine(string.Format("[{0}]MSMQChannel.Receiver.MessageDispatcher: Local endpoint={1}",
ChannelName, strObjectUrl));
// channel
Receiver rcv = this as Receiver;
// stack
ServerChannelSinkStack stack = new ServerChannelSinkStack();
stack.Push(rcv.TransportSink, null);
// request (workaround)
ITransportHeaders requestHeaders = null;
if(iMsgReq.Properties.Contains("__RequestHeaders"))
{
requestHeaders = iMsgReq.Properties["__RequestHeaders"] as ITransportHeaders;
}
else
{
requestHeaders = new TransportHeaders();
requestHeaders["__ContentType"] = "application/octet-stream";
}
requestHeaders["__RequestUri"] = "/" + strObjectUrl;
requestStream.Position = 0;
// response
Stream responseStream = null;
ITransportHeaders responseHeaders = null;
// skip the transport sink
rcv.TransportSink.NextChannelSink.ProcessMessage(stack, null, requestHeaders, requestStream,
out iMsgRsp, out responseHeaders, out responseStream);
}
else
{
// chaining channel
string strDummy = null;
IMessageSink sink = null;
// find a properly channel
foreach(IChannel ch in ChannelServices.RegisteredChannels)
{
if(ch is IChannelSender)
{
IChannelSender iChannelSender = ch as IChannelSender;
sink = iChannelSender.CreateMessageSink(strObjectUrl, null, out strDummy);
if(sink != null)
{
//this is a next channel
Trace.WriteLine(string.Format("[{0}]MSMQChannel.Receiver.MessageDispatcher: Chained channel is url={1}",
ChannelName, strObjectUrl));
break;
}
}
}
if(sink == null)
{
//no channel found it
string strError = string.Format("[{0}]MSMQChannel.Receiver.MessageDispatcher: A supported channel could not be found for {1}",
ChannelName, strObjectUrl);
iMsgRsp = new ReturnMessage(new Exception(strError), (IMethodCallMessage)iMsgReq);
Trace.WriteLine(strError);
}
else
{
//check for an oneway attribute
IMethodCallMessage mcm = iMsgReq as IMethodCallMessage;
if(RemotingServices.IsOneWay(mcm.MethodBase) == true)
iMsgRsp = (IMessage)sink.AsyncProcessMessage(iMsgReq, null);
else
iMsgRsp = sink.SyncProcessMessage(iMsgReq);
}
}
}
else
{
//exception
Exception ex = new Exception(string.Format("[{0}]MSMQChannel.Receiver.MessageDispatcher: The Uri address is null", ChannelName));
iMsgRsp = new ReturnMessage(ex, (IMethodCallMessage)iMsgReq);
}
// check the response message
if(iMsgRsp != null)
{
IMethodReturnMessage mrm = iMsgRsp as IMethodReturnMessage;
if(mrm.Exception != null)
throw mrm.Exception;
}
return iMsgRsp;
}
} // HttpHandlerTransportSink
public void HandleRequest(HttpContext context)
{
HttpRequest httpRequest = context.Request;
HttpResponse httpResponse = context.Response;
// get headers
BaseTransportHeaders requestHeaders = new BaseTransportHeaders();
requestHeaders["__RequestVerb"] = httpRequest.HttpMethod;
requestHeaders["__CustomErrorsEnabled"] = HttpRemotingHandler.CustomErrorsEnabled(context);
requestHeaders.RequestUri = (string)context.Items["__requestUri"];
NameValueCollection headers = httpRequest.Headers;
String[] allKeys = headers.AllKeys;
for (int httpKeyCount=0; httpKeyCount< allKeys.Length; httpKeyCount++)
{
String headerName = allKeys[httpKeyCount];
String headerValue = headers[headerName];
requestHeaders[headerName] = headerValue;
}
// add ip address to headers list
requestHeaders.IPAddress = IPAddress.Parse(httpRequest.UserHostAddress);
// get request stream
Stream requestStream = httpRequest.InputStream;
// process message
ServerChannelSinkStack sinkStack = new ServerChannelSinkStack();
sinkStack.Push(this, null);
IMessage responseMessage;
ITransportHeaders responseHeaders;
Stream responseStream;
ServerProcessing processing =
_nextSink.ProcessMessage(sinkStack, null, requestHeaders, requestStream,
out responseMessage,
out responseHeaders, out responseStream);
// handle response
switch (processing)
{
case ServerProcessing.Complete:
{
// Send the response. Call completed synchronously.
SendResponse(httpResponse, 200, responseHeaders, responseStream);
break;
} // case ServerProcessing.Complete
case ServerProcessing.OneWay:
{
// Just send back a 202 Accepted
SendResponse(httpResponse, 202, responseHeaders, responseStream);
break;
} // case ServerProcessing.OneWay
case ServerProcessing.Async:
{
// Async dispatching was cut from V.1.
//sinkStack.StoreAndDispatch(this, streamManager);
break;
}// case ServerProcessing.Async
} // switch (processing)
} // HandleRequest
internal void InternalProcessMessage (ClientConnection connection, Stream stream)
{
// Reads the headers and the request stream
Stream requestStream;
ITransportHeaders requestHeaders;
requestStream = UnixMessageIO.ReceiveMessageStream (stream, out requestHeaders, connection.Buffer);
/* try {
PeerCred cred = connection.Client.PeerCredential;
requestHeaders["__uid"] = cred.UserID;
} catch (Exception e) {
Console.WriteLine ("Couldn't get the peer cred: " + e);
}
*/
// Pushes the connection object together with the sink. This information
// will be used for sending the response in an async call.
ServerChannelSinkStack sinkStack = new ServerChannelSinkStack();
sinkStack.Push(this, connection);
ITransportHeaders responseHeaders;
Stream responseStream;
IMessage responseMsg;
ServerProcessing proc = next_sink.ProcessMessage(sinkStack, null, requestHeaders, requestStream, out responseMsg, out responseHeaders, out responseStream);
switch (proc)
{
case ServerProcessing.Complete:
UnixMessageIO.SendMessageStream (stream, responseStream, responseHeaders, connection.Buffer);
stream.Flush ();
break;
case ServerProcessing.Async:
case ServerProcessing.OneWay:
break;
}
}
/// <summary>
/// Sends request into infrastructure, then passes back result.
/// </summary>
/// <param name="hdr">Header contain request.</param>
private void handleRemotingRequest(StackHeader hdr)
{
IMessage responseMsg;
ITransportHeaders responseHeaders;
Stream responseStream;
IMessage req = hdr.Message;
ServerChannelSinkStack sinkStack = new ServerChannelSinkStack();
ProcessMessage(sinkStack,req,null,null,out responseMsg,out responseHeaders,out responseStream);
//send response back down the stack
Address dest = hdr.Source;
Message remotingMsg = new Message(dest,local_addr,null);
StackHeader rspHdr = new StackHeader(StackHeader.REMOTE_RSP,responseMsg, "");
remotingMsg.putHeader(name,rspHdr);
down(new Event(Event.MSG,remotingMsg));
}
internal void ServiceRequest(object state)
{
ITransportHeaders headers2;
Stream stream2;
ServerProcessing processing;
TcpServerSocketHandler handler = (TcpServerSocketHandler) state;
ITransportHeaders requestHeaders = handler.ReadHeaders();
Stream requestStream = handler.GetRequestStream();
requestHeaders["__CustomErrorsEnabled"] = handler.CustomErrorsEnabled();
ServerChannelSinkStack sinkStack = new ServerChannelSinkStack();
sinkStack.Push(this, handler);
WindowsIdentity impersonationIdentity = handler.ImpersonationIdentity;
WindowsImpersonationContext context = null;
IPrincipal currentPrincipal = null;
bool flag = false;
if (impersonationIdentity != null)
{
currentPrincipal = Thread.CurrentPrincipal;
flag = true;
if (this._impersonate)
{
Thread.CurrentPrincipal = new WindowsPrincipal(impersonationIdentity);
context = impersonationIdentity.Impersonate();
}
else
{
Thread.CurrentPrincipal = new GenericPrincipal(impersonationIdentity, null);
}
}
try
{
try
{
IMessage message;
processing = this._nextSink.ProcessMessage(sinkStack, null, requestHeaders, requestStream, out message, out headers2, out stream2);
}
finally
{
if (flag)
{
Thread.CurrentPrincipal = currentPrincipal;
}
if (this._impersonate)
{
context.Undo();
}
}
}
catch
{
throw;
}
switch (processing)
{
case ServerProcessing.Complete:
sinkStack.Pop(this);
handler.SendResponse(headers2, stream2);
break;
case ServerProcessing.OneWay:
handler.SendResponse(headers2, stream2);
break;
case ServerProcessing.Async:
sinkStack.StoreAndDispatch(this, handler);
break;
}
if (processing != ServerProcessing.Async)
{
if (handler.CanServiceAnotherRequest())
{
handler.BeginReadMessage();
}
else
{
handler.Close();
}
}
}
void ProcessClient(object state)
{
try
{
NamedPipeSocket socket = (NamedPipeSocket) state;
ITransportHeaders requestHeaders;
Stream requestStream;
IpcTransport t = new IpcTransport(socket);
t.Read(out requestHeaders, out requestStream);
// parse the RequestUri
string objectUri;
string uri = (string) requestHeaders[CommonTransportKeys.RequestUri];
IpcChannelHelper.Parse(uri, out objectUri);
if (objectUri == null) objectUri = uri;
requestHeaders[CommonTransportKeys.RequestUri] = objectUri;
ServerChannelSinkStack stack = new ServerChannelSinkStack();
stack.Push(this, null);
IMessage responseMsg;
ITransportHeaders responseHeaders;
Stream responseStream;
requestHeaders["__CustomErrorsEnabled"] = false;
if (impersonate)
{
// TODO: Impersonate might throw exceptions. What to do with them?
socket.Impersonate();
}
ServerProcessing op = nextSink.ProcessMessage(
stack,
null,
requestHeaders,
requestStream,
out responseMsg,
out responseHeaders,
out responseStream
);
if (impersonate)
{
NamedPipeSocket.RevertToSelf();
}
switch (op)
{
case ServerProcessing.Complete:
stack.Pop(this);
// send the response headers and the response data to the client
t.Write(responseHeaders, responseStream);
break;
case ServerProcessing.Async:
stack.StoreAndDispatch(nextSink, null);
break;
case ServerProcessing.OneWay:
break;
}
}
catch (Exception)
{
// Console.WriteLine(ex);
}
}
} // TcpServerTransportSink
internal void ServiceRequest(Object state)
{
TcpServerSocketHandler streamManager = (TcpServerSocketHandler)state;
ITransportHeaders headers = streamManager.ReadHeaders();
Stream requestStream = streamManager.GetRequestStream();
headers["__CustomErrorsEnabled"] = streamManager.CustomErrorsEnabled();
// process request
ServerChannelSinkStack sinkStack = new ServerChannelSinkStack();
sinkStack.Push(this, streamManager);
IMessage responseMessage;
ITransportHeaders responseHeaders;
Stream responseStream;
#if !FEATURE_PAL
// If Impersonation was requested impersonate the client identity
WindowsIdentity identity = streamManager.ImpersonationIdentity;
WindowsImpersonationContext context = null;
IPrincipal oldPrincipal = null;
bool principalChanged = false;
if(identity != null)
{
oldPrincipal = Thread.CurrentPrincipal;
principalChanged = true;
if (_impersonate)
{
Thread.CurrentPrincipal = new WindowsPrincipal(identity);
context = identity.Impersonate();
}
else
{
Thread.CurrentPrincipal = new GenericPrincipal(identity, null);
}
}
#endif // !FEATURE_PAL
ServerProcessing processing;
// wrap Undo in an outer try block
try{
try{
processing =
_nextSink.ProcessMessage(sinkStack, null, headers, requestStream,
out responseMessage,
out responseHeaders, out responseStream);
}
finally{
#if !FEATURE_PAL
// Revert the principal if we had changed the principal
if (principalChanged)
{
Thread.CurrentPrincipal = oldPrincipal;
}
// Revert the impersonation if we had impersonated
if (_impersonate)
{
context.Undo();
}
#endif // !FEATURE_PAL
}
}
catch { throw; }
// handle response
switch (processing)
{
case ServerProcessing.Complete:
{
// Send the response. Call completed synchronously.
sinkStack.Pop(this);
streamManager.SendResponse(responseHeaders, responseStream);
break;
} // case ServerProcessing.Complete
case ServerProcessing.OneWay:
{
// No response needed, but the following method will make sure that
// we send at least a skeleton reply if the incoming request was
// not marked OneWayRequest (client/server metadata could be out of
// [....]).
streamManager.SendResponse(responseHeaders, responseStream);
break;
} // case ServerProcessing.OneWay
case ServerProcessing.Async:
{
sinkStack.StoreAndDispatch(this, streamManager);
break;
}// case ServerProcessing.Async
} // switch (processing)
// async processing will take care if handling this later
if (processing != ServerProcessing.Async)
{
if (streamManager.CanServiceAnotherRequest())
streamManager.BeginReadMessage();
else
streamManager.Close();
}
} // ServiceRequest
void ProcessMessage(IPEndPoint remote, ITransportHeaders requestHeaders, Stream requestStream)
{
// parse request uri
var url = requestHeaders[CommonTransportKeys.RequestUri].ToString();
string objectUri;
UdpChannelHelper.Parse(url, out objectUri);
objectUri = objectUri ?? url;
requestHeaders[CommonTransportKeys.RequestUri] = objectUri;
IMessage responseMsg;
ITransportHeaders responseHeaders;
Stream responseStream;
// process message
var stack = new ServerChannelSinkStack();
stack.Push(this, null);
var operation = NextChannelSink.ProcessMessage(stack, null, requestHeaders, requestStream,
out responseMsg, out responseHeaders, out responseStream);
switch (operation)
{
case ServerProcessing.Complete:
stack.Pop(this);
var transport = new UdpTransport(new UdpClient());
transport.Write(responseHeaders, responseStream, remote);
break;
case ServerProcessing.Async:
stack.StoreAndDispatch(NextChannelSink, null);
break;
case ServerProcessing.OneWay:
break;
}
}
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);
}
}
