public ServerProcessing ProcessMessage(
IServerChannelSinkStack sinkStack,
IMessage requestMsg,
ITransportHeaders requestHeaders,
Stream requestStream,
out IMessage responseMsg,
out ITransportHeaders responseHeaders,
out Stream responseStream)
{
var ip = requestHeaders[CommonTransportKeys.IPAddress] as IPAddress;
CallContext.SetData("ClientIPAddress", ip);
var connectionId = (Int64)requestHeaders[CommonTransportKeys.ConnectionId];
CallContext.SetData("ClientConnectionId", connectionId);
if (_next != null)
{
var spres = _next.ProcessMessage (sinkStack,requestMsg, requestHeaders,requestStream,out responseMsg,out responseHeaders,out responseStream);
return spres;
}
else
{
responseMsg=null;
responseHeaders=null;
responseStream=null;
return new ServerProcessing();
}
}
/// <summary></summary>
public ServerProcessing ProcessMessage(
IServerChannelSinkStack sinkStack,
IMessage requestMsg,
ITransportHeaders requestHeaders,
Stream requestStream,
out IMessage responseMsg,
out ITransportHeaders responseHeaders,
out Stream responseStream)
{
if (NextChannelSink != null)
{
SetClientIpAddressDataHelper(requestHeaders);
ServerProcessing spres = NextChannelSink.ProcessMessage(
sinkStack,
requestMsg,
requestHeaders,
requestStream,
out responseMsg,
out responseHeaders,
out responseStream);
return spres;
}
responseMsg = null;
responseHeaders = null;
responseStream = null;
return new ServerProcessing();
}
public ServerProcessing ProcessMessage(
IServerChannelSinkStack sinkStack_in,
IMessage requestMsg_in,
ITransportHeaders requestHeaders_in,
Stream requestStream_in,
out IMessage responseMsg_out,
out ITransportHeaders responseHeaders_out,
out Stream responseStream_out
) {
if (nextchannelsink_ != null) {
CallContext.SetData(
"ClientIPAddress",
((IPAddress)requestHeaders_in[CommonTransportKeys.IPAddress]).ToString()
);
ServerProcessing _serverprocessing = NextChannelSink.ProcessMessage(
sinkStack_in,
requestMsg_in,
requestHeaders_in,
requestStream_in,
out responseMsg_out,
out responseHeaders_out,
out responseStream_out
);
return _serverprocessing;
} else {
responseMsg_out = null;
responseHeaders_out = null;
responseStream_out = null;
return new ServerProcessing();
}
}
public ServerProcessing ProcessMessage (IServerChannelSinkStack sinkStack, IMessage requestMsg,
ITransportHeaders requestHeaders, Stream requestStream, out IMessage responseMsg,
out ITransportHeaders responseHeaders, out Stream responseStream)
{
//we know we never call this
throw new NotSupportedException ();
}
[System.Security.SecurityCritical] // auto-generated
public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack,
IMessage requestMsg,
ITransportHeaders requestHeaders, Stream requestStream,
out IMessage responseMsg, out ITransportHeaders responseHeaders,
out Stream responseStream)
{
if (requestMsg == null)
{
throw new ArgumentNullException(
"requestMsg",
Environment.GetResourceString("Remoting_Channel_DispatchSinkMessageMissing"));
}
Contract.EndContractBlock();
// check arguments
if (requestStream != null)
{
throw new RemotingException(
Environment.GetResourceString("Remoting_Channel_DispatchSinkWantsNullRequestStream"));
}
responseHeaders = null;
responseStream = null;
return ChannelServices.DispatchMessage(sinkStack, requestMsg, out responseMsg);
} // ProcessMessage
public ServerProcessing ProcessMessage (IServerChannelSinkStack sinkStack,
IMessage requestMsg,
ITransportHeaders requestHeaders,
Stream requestStream,
out IMessage responseMsg,
out ITransportHeaders responseHeaders,
out Stream responseStream)
{
IMessage call;
MessageType mtype = (Ice.MessageType) requestHeaders["__iceMessageType"];
bool isBatched = (mtype == Ice.MessageType.BatchRequest);
try {
if (requestMsg == null) {
requestMsg = IceChannelUtils.ProtocolRequestToMessage (requestStream, isBatched);
} else {
call = requestMsg;
}
Trace.WriteLine ("IceServerFormatterSink: passing upstream");
_next.ProcessMessage (sinkStack, requestMsg, requestHeaders, null,
out responseMsg, out responseHeaders, out responseStream);
Trace.WriteLine ("IceServerFormatterSink: returned");
responseStream = new MemoryStream();
IceChannelUtils.MessageToProtocolReply (requestMsg, responseMsg, responseStream);
} catch (Exception e) {
Console.WriteLine (e.ToString());
throw e;
}
return ServerProcessing.Complete;
}
public ServerProcessing ProcessMessage(
IServerChannelSinkStack sinkStack,
IMessage requestMsg,
ITransportHeaders requestHeaders,
Stream requestStream,
out IMessage responseMsg,
out ITransportHeaders responseHeaders,
out Stream responseStream)
{
if (_nextSink != null)
{
IPAddress ip =
requestHeaders[CommonTransportKeys.IPAddress] as IPAddress;
CallContext.SetData("ClientIPAddress", ip);
ServerProcessing spres = _nextSink.ProcessMessage(
sinkStack,
requestMsg,
requestHeaders,
requestStream,
out responseMsg,
out responseHeaders,
out responseStream);
return spres;
}
else
{
responseMsg = null;
responseHeaders = null;
responseStream = null;
return new ServerProcessing();
}
}
public ServerProcessing ProcessMessage (IServerChannelSinkStack sinkStack,
IMessage requestMsg,
ITransportHeaders requestHeaders,
Stream requestStream,
out IMessage responseMsg,
out ITransportHeaders responseHeaders,
out Stream responseStream)
{
IMessage call;
string uri = (string)requestHeaders [CommonTransportKeys.RequestUri];
if (requestMsg == null) {
call = (IMessage)format.DeserializeRequest (requestStream, uri);
} else {
call = requestMsg;
}
next_sink.ProcessMessage (sinkStack, call, requestHeaders, null,
out responseMsg, out responseHeaders, out responseStream);
responseStream = new MemoryStream ();
format.SerializeResponse (responseStream, responseMsg);
return ServerProcessing.Complete;
}
public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack, IMessage requestMessage, ITransportHeaders requestHeaders, Stream requestStream, out IMessage responseMessage, out ITransportHeaders responseHeaders, out Stream responseStream)
{
requestStream = Zip.Decompress(requestStream);
sinkStack.Push(this, null);
ServerProcessing processing = this.m_NextSink.ProcessMessage(sinkStack, requestMessage, requestHeaders, requestStream, out responseMessage, out responseHeaders, out responseStream);
responseStream = Zip.Compress(responseStream);
return processing;
}
public static ServerProcessing DispatchMessage(IServerChannelSinkStack sinkStack, System.Runtime.Remoting.Messaging.IMessage msg, out System.Runtime.Remoting.Messaging.IMessage replyMsg)
{
Contract.Ensures(((System.Runtime.Remoting.Channels.ServerProcessing)(0)) <= Contract.Result<System.Runtime.Remoting.Channels.ServerProcessing>());
Contract.Ensures(Contract.Result<System.Runtime.Remoting.Channels.ServerProcessing>() <= ((System.Runtime.Remoting.Channels.ServerProcessing)(1)));
replyMsg = default(System.Runtime.Remoting.Messaging.IMessage);
return default(ServerProcessing);
}
public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack, IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream, out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream)
{
if(requestMsg is IMethodCallMessage)
{
IMethodCallMessage call = (IMethodCallMessage)requestMsg;
if(!provider.Filter(call.MethodBase))
throw new MemberAccessException("You are not allowed to access this member via remoting!");
}
return next.ProcessMessage(sinkStack, requestMsg, requestHeaders, requestStream, out responseMsg, out responseHeaders, out responseStream);
}
public ServerProcessing ProcessMessage (IServerChannelSinkStack sinkStack,
IMessage requestMsg,
ITransportHeaders requestHeaders,
Stream requestStream,
out IMessage responseMsg,
out ITransportHeaders responseHeaders,
out Stream responseStream)
{
// this is the first sink, and SimpleServerChannel does not call it.
throw new NotSupportedException ();
}
public ServerProcessing ProcessMessage (IServerChannelSinkStack sinkStack,
IMessage requestMsg,
ITransportHeaders requestHeaders,
Stream requestStream,
out IMessage responseMsg,
out ITransportHeaders responseHeaders,
out Stream responseStream)
{
// this sink is always first, and this method isn't usued as the entry point
throw new NotSupportedException();
}
public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack, IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream, out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream)
{
if (this._nextSink != null)
{
object obj1 = requestHeaders["__IPAddress"];
return this._nextSink.ProcessMessage(sinkStack, requestMsg, requestHeaders, requestStream, out responseMsg, out responseHeaders, out responseStream);
}
responseMsg = null;
responseHeaders = null;
responseStream = null;
return ServerProcessing.Complete;
}
public static ServerProcessing DispatchMessage
(IServerChannelSinkStack sinkStack, IMessage msg,
out IMessage replyMsg)
{
if(msg == null)
{
throw new ArgumentNullException("msg");
}
// TODO
replyMsg = null;
return ServerProcessing.Complete;
}
public ServerProcessing ProcessMessage (IServerChannelSinkStack sinkStack,
IMessage requestMsg,
ITransportHeaders requestHeaders,
Stream requestStream,
out IMessage responseMsg,
out ITransportHeaders responseHeaders,
out Stream responseStream)
{
responseHeaders = null;
responseStream = null;
return ChannelServices.DispatchMessage(sinkStack, requestMsg, out responseMsg);
}
ServerProcessing IServerChannelSink.ProcessMessage(IServerChannelSinkStack sinkStack, IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream, out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream)
{
BinaryFormatter binaryFormatter = new BinaryFormatter();
binaryFormatter.Binder = new GenericsVTSSerializationBinder();
requestMsg = (IMessage)binaryFormatter.Deserialize(requestStream);
requestMsg.Properties["__Uri"] = requestHeaders["__RequestUri"];
next.ProcessMessage(sinkStack, requestMsg, null, null, out responseMsg, out responseHeaders, out responseStream);
responseHeaders = new TransportHeaders();
responseStream = new MemoryStream();
binaryFormatter.Serialize(responseStream, responseMsg);
responseStream.Position = 0;
return ServerProcessing.Complete;
}
public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack, IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream, out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream)
{
IPAddress address = requestHeaders["__IPAddress"] as IPAddress;
Console.Write("Process message from {0} ... ", address);
if (!this.MatchIPAddress(address) ^ this.m_IsAccept)
{
TraceInfoEvent.Raise(string.Format("{0} is accepted by IPFilterChannelSink.", address));
Console.WriteLine("accepted");
return this.m_NextSink.ProcessMessage(sinkStack, requestMsg, requestHeaders, requestStream, out responseMsg, out responseHeaders, out responseStream);
}
TraceInfoEvent.Raise(string.Format("{0} is rejected by IPFilterChannelSink.", address));
responseHeaders = new TransportHeaders();
responseMsg = null;
responseStream = null;
return ServerProcessing.Complete;
}
public ServerProcessing ProcessMessage(
IServerChannelSinkStack sinkStack,
IMessage requestMsg,
ITransportHeaders requestHeaders,
Stream requestStream,
out IMessage responseMsg,
out ITransportHeaders responseHeaders,
out Stream responseStream)
{
try
{
if (_next != null)
{
ip = (IPAddress)requestHeaders[CommonTransportKeys.IPAddress];
if (ip != null && (ip.ToString().Trim() == "127.0.0.1" || CheckAuthorizedIP(ip.ToString())))
{
Common.CurrentStatus(ip.ToString().Trim());
ServerProcessing spres = _next.ProcessMessage(sinkStack, requestMsg, requestHeaders, requestStream, out responseMsg, out responseHeaders, out responseStream);
return spres;
}
else
{
Common.Log("Unauthorized Remoting IP: " + ip.ToString().Trim());
responseMsg = null;
responseHeaders = null;
responseStream = null;
return new ServerProcessing();
}
}
else
{
responseMsg = null;
responseHeaders = null;
responseStream = null;
return new ServerProcessing();
}
}
catch (Exception err)
{
Common.Log(err);
responseMsg = null;
responseHeaders = null;
responseStream = null;
return new ServerProcessing();
}
}
public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack, IMessage requestMessage, ITransportHeaders requestHeaders, Stream requestStream, out IMessage responseMessage, out ITransportHeaders responseHeaders, out Stream responseStream)
{
if (this.m_NextSink != null)
{
LogicalCallContext context = (LogicalCallContext) requestMessage.Properties["__CallContext"];
if ((context != null) && (context.GetData("PrincipalContextData") != null))
{
PrincipalContextData data = (PrincipalContextData) context.GetData("PrincipalContextData");
Thread.CurrentPrincipal = data.Principal;
}
return this.m_NextSink.ProcessMessage(sinkStack, requestMessage, requestHeaders, requestStream, out responseMessage, out responseHeaders, out responseStream);
}
responseMessage = null;
responseHeaders = null;
responseStream = null;
return ServerProcessing.Complete;
}
public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack, IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream, out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream)
{
sinkStack.Push(this, null);
ServerProcessing serverProcessing = _nextSink.ProcessMessage(sinkStack, requestMsg, requestHeaders, requestStream, out responseMsg, out responseHeaders, out responseStream);
switch (serverProcessing)
{
case ServerProcessing.Async:
sinkStack.StoreAndDispatch(this, null);
return serverProcessing;
case ServerProcessing.OneWay:
case ServerProcessing.Complete:
sinkStack.Pop(this);
return serverProcessing;
default:
return serverProcessing;
}
}
public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack, IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream, out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream)
{
bool clientCompressed = false;
// decompress the shits
Stream decompressedStream;
if (object.Equals(requestHeaders[CompressionHelper.CompressKey], CompressionHelper.CompressedFlag)) {
//Debug.WriteLine("client compressed");
clientCompressed = true;
decompressedStream = CompressionHelper.DecompressStream(requestStream);
// close the request stream
requestStream.Close();
}
else {
if (object.Equals(requestHeaders[CompressionHelper.CompressKey], CompressionHelper.CompressRequest)) {
//Debug.WriteLine("client requesting compress");
clientCompressed = true;
}
decompressedStream = requestStream;
}
sinkStack.Push(this, new ClientState(clientCompressed));
// send the decompressed message on through the sink chain
ServerProcessing processingResult = _next.ProcessMessage(sinkStack, requestMsg, requestHeaders, decompressedStream, out responseMsg, out responseHeaders, out responseStream);
// get the compressed stream
if (clientCompressed && processingResult == ServerProcessing.Complete) {
Stream compressedStream = CompressionHelper.CompressStream(responseStream);
responseStream.Close();
responseStream = compressedStream;
responseHeaders[CompressionHelper.CompressKey] = CompressionHelper.CompressedFlag;
}
// Take us off the stack and return the result.
if (processingResult == ServerProcessing.Async) {
sinkStack.Store(this, new ClientState(clientCompressed));
}
else {
sinkStack.Pop(this);
}
return processingResult;
}
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 m_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
{
MethodCall 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
m_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();
XmlRpcFaultException fex = new XmlRpcFaultException(0, ex.Message);
XmlRpcSerializer serializer = new XmlRpcSerializer();
serializer.SerializeFaultResponse(responseStream,
(XmlRpcFaultException)fex);
responseHeaders = new TransportHeaders();
}
return ServerProcessing.Complete;
}
ServerProcessing IServerChannelSink.ProcessMessage(IServerChannelSinkStack sinkStack, System.Runtime.Remoting.Messaging.IMessage requestMsg, ITransportHeaders requestHeaders, System.IO.Stream requestStream, out System.Runtime.Remoting.Messaging.IMessage responseMsg, out ITransportHeaders responseHeaders, out System.IO.Stream responseStream)
{
if (Application.OpenForms.Count > 0) {
IMessage outResponseMsg = null;
ITransportHeaders outResponseHeaders = null;
Stream outResponseStream = null;
ServerProcessing returnValue = ServerProcessing.Complete;
Application.OpenForms[0].Invoke(new EventHandler(delegate
{
returnValue = nextSink.ProcessMessage(sinkStack, requestMsg, requestHeaders, requestStream, out outResponseMsg, out outResponseHeaders, out outResponseStream);
}));
responseMsg = outResponseMsg;
responseHeaders = outResponseHeaders;
responseStream = outResponseStream;
return returnValue;
} else {
return nextSink.ProcessMessage(sinkStack, requestMsg, requestHeaders, requestStream, out responseMsg, out responseHeaders, out responseStream);
}
}
public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack,
IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream,
out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream)
{
object handback = ContextUtil.NotifyServerMessage(requestMsg, requestHeaders);
sinkStack.Push(this, handback);
ServerProcessing result = _nextSink.ProcessMessage(sinkStack,
requestMsg, requestHeaders, requestStream,
out responseMsg,
out responseHeaders,
out responseStream);
if (result != ServerProcessing.Async)
{
ContextUtil.NotifyServerMessageResponse(responseMsg, responseHeaders, handback);
}
return result;
}
public ServerProcessing ProcessMessage (IServerChannelSinkStack sinkStack,
IMessage requestMsg,
ITransportHeaders requestHeaders,
Stream requestStream,
out IMessage responseMsg,
out ITransportHeaders responseHeaders,
out Stream responseStream)
{
responseMsg = null;
responseStream = null;
responseHeaders = null;
string verb = requestHeaders [CommonTransportKeys.RequestVerb] as string;
string uri = (string) requestHeaders [CommonTransportKeys.RequestUri];
if (verb == "GET" && uri.EndsWith ("?wsdl"))
{
try
{
uri = uri.Substring (0, uri.Length - 5);
Type type = RemotingServices.GetServerTypeForUri (uri);
string url = _channel.GetUrlsForUri (uri)[0];
ServiceType st = new ServiceType (type, url);
responseStream = new MemoryStream ();
MetaData.ConvertTypesToSchemaToStream (new ServiceType[] {st}, SdlType.Wsdl, responseStream);
responseStream.Position = 0;
responseMsg = null;
responseHeaders = new TransportHeaders ();
responseHeaders [CommonTransportKeys.ContentType] = "text/xml";
}
catch (Exception ex)
{
responseHeaders = new TransportHeaders ();
responseHeaders [CommonTransportKeys.HttpStatusCode] = "400";
responseStream = new MemoryStream (Encoding.UTF8.GetBytes (ex.ToString ()));
}
return ServerProcessing.Complete;
}
else
return _next.ProcessMessage (sinkStack, requestMsg, requestHeaders, requestStream, out responseMsg, out responseHeaders, out responseStream);
}
public ServerProcessing ProcessMessage (IServerChannelSinkStack sinkStack,
IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream,
out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream)
{
IMethodCallMessage msg = (IMethodCallMessage) requestMsg;
// Console.WriteLine ("MESSAGE: " + msg.TypeName + " - " + msg.MethodName);
sinkStack.Push (this, null);
if (Attribute.IsDefined (msg.MethodBase, typeof(NoGuiDispatchAttribute))) {
ServerProcessing ret;
try {
ret = nextSink.ProcessMessage (sinkStack,
requestMsg,
requestHeaders,
requestStream,
out responseMsg,
out responseHeaders,
out responseStream);
} finally {
sinkStack.Pop (this);
}
return ret;
}
else
{
Dispatcher d = new Dispatcher ();
d.nextSink = nextSink;
d.sinkStack = sinkStack;
d.requestMsg = requestMsg;
d.requestHeaders = requestHeaders;
d.requestStream = requestStream;
Gtk.Application.Invoke (d.Dispatch);
responseMsg = null;
responseHeaders = null;
responseStream = null;
return ServerProcessing.Async;
}
}
public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack,
IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream,
out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream)
{
if (requestHeaders["SOAPAction"] != null)
{
// pass to next sink if this is a SOAP request with SOAPAction header.
return NextChannelSink.ProcessMessage(sinkStack,
requestMsg, requestHeaders, requestStream,
out responseMsg, out responseHeaders, out responseStream);
}
XmlRpcHttpRequestConfig requestConfig = GetConfig(requestHeaders);
try
{
MethodCall call = DeserializeRequest(requestHeaders, requestStream, requestConfig);
sinkStack.Push(this, call);
// forward to next sink in chain - pass request stream as null to
// indicate that we have deserialized the request
NextChannelSink.ProcessMessage(sinkStack, call, requestHeaders, null,
out responseMsg, out responseHeaders, out responseStream);
SerializeResponse(responseMsg, ref responseHeaders, ref responseStream, requestConfig);
}
catch (Exception ex)
{
responseMsg = new ReturnMessage(ex, (IMethodCallMessage)requestMsg);
responseStream = new MemoryStream();
XmlRpcResponseSerializer serializer = new XmlRpcResponseSerializer();
XmlRpcResponse faultResponse = new XmlRpcResponse();
faultResponse.Fault = new XmlRpcFault(0, ex.Message);
serializer.WriteResponse(responseStream, faultResponse, requestConfig, TypeSerializerFactory);
responseHeaders = new TransportHeaders();
responseHeaders["Content-Type"] = "text/xml; charset=\"utf-8\"";
}
return ServerProcessing.Complete;
}
public static ServerProcessing DispatchMessage(IServerChannelSinkStack sinkStack, System.Runtime.Remoting.Messaging.IMessage msgout, System.Runtime.Remoting.Messaging.IMessage& replyMsg)
{
}
public static ServerProcessing DispatchMessage (
IServerChannelSinkStack sinkStack,
IMessage msg,
out IMessage replyMsg)
{
if (msg == null) throw new ArgumentNullException ("msg");
// Async processing is not done here because there isn't any way
// to know if a message is to be dispatched sync or asynchronously.
replyMsg = SyncDispatchMessage (msg);
if (RemotingServices.IsOneWay (((IMethodMessage) msg).MethodBase))
return ServerProcessing.OneWay;
else
return ServerProcessing.Complete;
}
public ServerProcessing ProcessMessage(
IServerChannelSinkStack sinkStack_in,
IMessage requestMsg_in,
ITransportHeaders requestHeaders_in,
Stream requestStream_in,
out IMessage responseMsg_out,
out ITransportHeaders responseHeaders_out,
out Stream responseStream_out
)
{
#if DEBUG
Console.WriteLine("compression sink: ProcessMessage...");
#endif
bool _isCompressed = false;
if (isHeaderCompressed_(requestHeaders_in))
{
#region uncompress...
requestStream_in
= CompressionHelper.GetUncompressedStreamCopy(
requestStream_in
);
_isCompressed = true;
#endregion
}
else
{
if (this.mustdo_)
{
throw new Exception("\n\n\t\tyour activity is being logged!\n\n\t\tun-compressed communications not allowed!\n\n");
}
}
sinkStack_in.Push(
this,
_isCompressed
);
ServerProcessing _output = this.nextchannelsink_.ProcessMessage(
sinkStack_in,
requestMsg_in,
requestHeaders_in,
requestStream_in,
out responseMsg_out,
out responseHeaders_out,
out responseStream_out
);
if (_output == ServerProcessing.Complete)
{
if (_isCompressed)
{
#region compress...
responseHeaders_out[CompressionHelper.X_COMPRESS] = "1";
responseStream_out
= CompressionHelper.GetCompressedStreamCopy(
responseStream_out
);
#endregion
}
}
//// previously checked!
//else {
// if (mustdo_) {
// throw new Exception("\n\n\t\tyour activity is being logged!\n\n\t\tun-compressed communications not allowed!\n\n");
// }
//}
return(_output);
}
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);
}
if (requestHeaders == null)
throw new ArgumentNullException("requestHeaders");
BaseTransportHeaders wkRequestHeaders = requestHeaders as BaseTransportHeaders;
ServerProcessing processing;
responseHeaders = null;
responseStream = null;
String verb = null;
String contentType = null;
bool bCanServiceRequest = true;
// determine the content type
String contentTypeHeader = null;
if (wkRequestHeaders != null)
contentTypeHeader = wkRequestHeaders.ContentType;
else
contentTypeHeader = requestHeaders["Content-Type"] as String;
if (contentTypeHeader != null)
{
String charsetValue;
HttpChannelHelper.ParseContentType(contentTypeHeader,
out contentType, out charsetValue);
}
// check to see if Content-Type matches
if ((contentType != null) &&
(String.CompareOrdinal(contentType, CoreChannel.BinaryMimeType) != 0))
{
bCanServiceRequest = false;
}
// check for http specific verbs
if (_protocol == Protocol.Http)
{
verb = (String)requestHeaders["__RequestVerb"];
if (!verb.Equals("POST") && !verb.Equals("M-POST"))
bCanServiceRequest = false;
}
// either delegate or return an error message if we can't service the request
if (!bCanServiceRequest)
{
// delegate to next sink if available
if (_nextSink != null)
{
return _nextSink.ProcessMessage(sinkStack, null, requestHeaders, requestStream,
out responseMsg, out responseHeaders, out responseStream);
}
else
{
// send back an error message
if (_protocol == Protocol.Http)
{
// return a client bad request error
responseHeaders = new TransportHeaders();
responseHeaders["__HttpStatusCode"] = "400";
responseHeaders["__HttpReasonPhrase"] = "Bad Request";
responseStream = null;
responseMsg = null;
return ServerProcessing.Complete;
}
else
{
// The transport sink will catch this and do something here.
throw new RemotingException(
CoreChannel.GetResourceString("Remoting_Channels_InvalidRequestFormat"));
}
}
}
try
{
String objectUri = null;
bool bIsCustomErrorEnabled = true;
object oIsCustomErrorEnabled = requestHeaders["__CustomErrorsEnabled"];
if (oIsCustomErrorEnabled != null && oIsCustomErrorEnabled is bool){
bIsCustomErrorEnabled = (bool)oIsCustomErrorEnabled;
}
CallContext.SetData("__CustomErrorsEnabled", bIsCustomErrorEnabled);
if (wkRequestHeaders != null)
objectUri = wkRequestHeaders.RequestUri;
else
objectUri = (String)requestHeaders[CommonTransportKeys.RequestUri];
if (objectUri != lastUri && RemotingServices.GetServerTypeForUri(objectUri) == null)
throw new RemotingException(
CoreChannel.GetResourceString("Remoting_ChnlSink_UriNotPublished"));
else
lastUri = objectUri;
PermissionSet currentPermissionSet = null;
if (this.TypeFilterLevel != TypeFilterLevel.Full) {
currentPermissionSet = new PermissionSet(PermissionState.None);
currentPermissionSet.SetPermission(new SecurityPermission(SecurityPermissionFlag.SerializationFormatter));
}
try {
if (currentPermissionSet != null)
currentPermissionSet.PermitOnly();
// Deserialize Request - Stream to IMessage
requestMsg = CoreChannel.DeserializeBinaryRequestMessage(objectUri, requestStream, _strictBinding, this.TypeFilterLevel);
}
finally {
if (currentPermissionSet != null)
CodeAccessPermission.RevertPermitOnly();
}
requestStream.Close();
if(requestMsg == null)
{
throw new RemotingException(CoreChannel.GetResourceString("Remoting_DeserializeMessage"));
}
// Transparent proxy IMessages are allowed conditionally by AppSettings
if (RemotingServices.IsTransparentProxy(requestMsg) && !AppSettings.AllowTransparentProxyMessage)
{
// Null request to prevent calling transparent proxy methods in catch below.
// Fwlink is provided to explain why it is not supported. Inner exceptions propagate back to sender.
requestMsg = null;
throw new RemotingException(CoreChannel.GetResourceString("Remoting_DeserializeMessage"),
new NotSupportedException(AppSettings.AllowTransparentProxyMessageFwLink));
}
// Dispatch Call
sinkStack.Push(this, null);
processing =
_nextSink.ProcessMessage(sinkStack, requestMsg, requestHeaders, null,
out responseMsg, out responseHeaders, out responseStream);
// make sure that responseStream is null
if (responseStream != null)
{
throw new RemotingException(
CoreChannel.GetResourceString("Remoting_ChnlSink_WantNullResponseStream"));
}
switch (processing)
{
case ServerProcessing.Complete:
{
if (responseMsg == null)
throw new RemotingException(CoreChannel.GetResourceString("Remoting_DispatchMessage"));
sinkStack.Pop(this);
SerializeResponse(sinkStack, responseMsg,
ref responseHeaders, out responseStream);
break;
} // case ServerProcessing.Complete
case ServerProcessing.OneWay:
{
sinkStack.Pop(this);
break;
} // case ServerProcessing.OneWay:
case ServerProcessing.Async:
{
sinkStack.Store(this, null);
break;
} // case ServerProcessing.Async
} // switch (processing)
}
catch(Exception e)
{
processing = ServerProcessing.Complete;
responseMsg = new ReturnMessage(e, (IMethodCallMessage)(requestMsg==null?new ErrorMessage():requestMsg));
//
CallContext.SetData("__ClientIsClr", true);
responseStream = (MemoryStream)CoreChannel.SerializeBinaryMessage(responseMsg, _includeVersioning);
CallContext.FreeNamedDataSlot("__ClientIsClr");
responseStream.Position = 0;
responseHeaders = new TransportHeaders();
if (_protocol == Protocol.Http)
{
responseHeaders["Content-Type"] = CoreChannel.BinaryMimeType;
}
}
finally{
CallContext.FreeNamedDataSlot("__CustomErrorsEnabled");
}
return processing;
} // ProcessMessage
public static ServerProcessing DispatchMessage(IServerChannelSinkStack sinkStack, IMessage msg, out IMessage replyMsg)
{
ServerProcessing serverProcessing = ServerProcessing.Complete;
replyMsg = null;
try
{
if (msg == null)
{
throw new ArgumentNullException("msg");
}
ChannelServices.IncrementRemoteCalls();
ServerIdentity serverIdentity = ChannelServices.CheckDisconnectedOrCreateWellKnownObject(msg);
if (serverIdentity.ServerType == typeof(AppDomain))
{
throw new RemotingException(Environment.GetResourceString("Remoting_AppDomainsCantBeCalledRemotely"));
}
IMethodCallMessage methodCallMessage = msg as IMethodCallMessage;
if (methodCallMessage == null)
{
if (!typeof(IMessageSink).IsAssignableFrom(serverIdentity.ServerType))
{
throw new RemotingException(Environment.GetResourceString("Remoting_AppDomainsCantBeCalledRemotely"));
}
serverProcessing = ServerProcessing.Complete;
replyMsg = ChannelServices.GetCrossContextChannelSink().SyncProcessMessage(msg);
}
else
{
MethodInfo methodInfo = (MethodInfo)methodCallMessage.MethodBase;
if (!ChannelServices.IsMethodReallyPublic(methodInfo) && !RemotingServices.IsMethodAllowedRemotely(methodInfo))
{
throw new RemotingException(Environment.GetResourceString("Remoting_NonPublicOrStaticCantBeCalledRemotely"));
}
RemotingMethodCachedData reflectionCachedData = InternalRemotingServices.GetReflectionCachedData(methodInfo);
if (RemotingServices.IsOneWay(methodInfo))
{
serverProcessing = ServerProcessing.OneWay;
ChannelServices.GetCrossContextChannelSink().AsyncProcessMessage(msg, null);
}
else
{
serverProcessing = ServerProcessing.Complete;
if (!serverIdentity.ServerType.IsContextful)
{
object[] args = new object[]
{
msg,
serverIdentity.ServerContext
};
replyMsg = (IMessage)CrossContextChannel.SyncProcessMessageCallback(args);
}
else
{
replyMsg = ChannelServices.GetCrossContextChannelSink().SyncProcessMessage(msg);
}
}
}
}
catch (Exception e)
{
if (serverProcessing != ServerProcessing.OneWay)
{
try
{
IMessage message2;
if (msg == null)
{
IMessage message = new ErrorMessage();
message2 = message;
}
else
{
message2 = msg;
}
IMethodCallMessage mcm = (IMethodCallMessage)message2;
replyMsg = new ReturnMessage(e, mcm);
if (msg != null)
{
((ReturnMessage)replyMsg).SetLogicalCallContext((LogicalCallContext)msg.Properties[Message.CallContextKey]);
}
}
catch (Exception)
{
}
}
}
return(serverProcessing);
}
