We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

The Labs \ Source Viewer \ SSCLI \ System.Runtime.Remoting.Channels \ BinaryClientFormatterSink

SSCLI
  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  15. //==========================================================================
  16. // File: BinaryFormatterSinks.cs
  17. //
  18. // Summary: Binary formatter client and server sinks.
  19. //
  20. //==========================================================================
  23. using System;
  24. using System.Collections;
  25. using System.IO;
  26. using System.Reflection;
  27. using System.Runtime.Serialization.Formatters;
  28. using System.Runtime.Remoting;
  29. using System.Runtime.Remoting.Channels;
  30. using System.Runtime.Remoting.Channels.Http;
  31. using System.Runtime.Remoting.Messaging;
  32. using System.Runtime.Remoting.Metadata;
  33. using System.Security;
  34. using System.Security.Permissions;
  35. using System.Globalization;
  38. namespace System.Runtime.Remoting.Channels
  39. {
  40.    
  41.     //
  42.     // CLIENT-SIDE BINARY FORMATTER SINKS
  43.     //
  44.    
  45.     public class BinaryClientFormatterSinkProvider : IClientFormatterSinkProvider
  46.     {
  47.         private IClientChannelSinkProvider _next;
  48.        
  49.         // settings from config
  50.         private bool _includeVersioning = true;
  51.         private bool _strictBinding = false;
  52.        
  53.        
  54.         public BinaryClientFormatterSinkProvider()
  55.         {
  56.         }
  57.         // BinaryClientFormatterSinkProvider
  58.        
  59.         public BinaryClientFormatterSinkProvider(IDictionary properties, ICollection providerData)
  60.         {
  61.             // look at properties
  62.             if (properties != null) {
  63.                 foreach (DictionaryEntry entry in properties) {
  64.                     string keyStr = entry.Key.ToString();
  65.                     switch (keyStr) {
  66.                         case "includeVersions":
  67.                             _includeVersioning = Convert.ToBoolean(entry.Value, CultureInfo.InvariantCulture);
  68.                             break;
  69.                         case "strictBinding":
  70.                             _strictBinding = Convert.ToBoolean(entry.Value, CultureInfo.InvariantCulture);
  71.                             break;
  72.                         default:
  73.                            
  74.                             break;
  75.                     }
  76.                 }
  77.             }
  78.            
  79.             // not expecting any provider data
  80.             CoreChannel.VerifyNoProviderData(this.GetType().Name, providerData);
  81.         }
  82.         // BinaryClientFormatterSinkProvider
  83.        
  84.         [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure, Infrastructure = true)]
  85.         public IClientChannelSink CreateSink(IChannelSender channel, string url, object remoteChannelData)
  86.         {
  87.             IClientChannelSink nextSink = null;
  88.             if (_next != null) {
  89.                 nextSink = _next.CreateSink(channel, url, remoteChannelData);
  90.                 if (nextSink == null)
  91.                     return null;
  92.             }
  93.            
  94.             SinkChannelProtocol protocol = CoreChannel.DetermineChannelProtocol(channel);
  95.            
  96.             BinaryClientFormatterSink sink = new BinaryClientFormatterSink(nextSink);
  97.             sink.IncludeVersioning = _includeVersioning;
  98.             sink.StrictBinding = _strictBinding;
  99.             sink.ChannelProtocol = protocol;
  100.             return sink;
  101.         }
  102.         // CreateSink
  103.         public IClientChannelSinkProvider Next {
  104.             [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure, Infrastructure = true)]
  105.             get { return _next; }
  106.             [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure, Infrastructure = true)]
  107.             set { _next = value; }
  108.         }
  109.     }
  110.     // class BinaryClientFormatterSinkProvider
  111.    
  112.     public class BinaryClientFormatterSink : IClientFormatterSink
  113.     {
  114.         private IClientChannelSink _nextSink = null;
  115.        
  116.         private bool _includeVersioning = true;
  117.         // should versioning be used
  118.         private bool _strictBinding = false;
  119.         // strict binding should be used
  120.         private SinkChannelProtocol _channelProtocol = SinkChannelProtocol.Other;
  121.        
  122.        
  123.         public BinaryClientFormatterSink(IClientChannelSink nextSink)
  124.         {
  125.             _nextSink = nextSink;
  126.         }
  127.         // BinaryClientFormatterSink
  128.         internal bool IncludeVersioning {
  129.             set { _includeVersioning = value; }
  130.         }
  131.         // IncludeVersioning
  132.         internal bool StrictBinding {
  133.             set { _strictBinding = value; }
  134.         }
  135.         // StrictBinding
  136.         internal SinkChannelProtocol ChannelProtocol {
  137.             set { _channelProtocol = value; }
  138.         }
  139.         // ChannelProtocol
  140.        
  141.        
  142.         public IMessageSink NextSink {
  143.             [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure, Infrastructure = true)]
  144.             get {
  145.                 throw new NotSupportedException();
  146.             }
  147.         }
  148.        
  149.         [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure, Infrastructure = true)]
  150.         public IMessage SyncProcessMessage(IMessage msg)
  151.         {
  152.             IMethodCallMessage mcm = msg as IMethodCallMessage;
  153.             IMessage retMsg;
  154.            
  155.             try {
  156.                 // serialize message
  157.                 ITransportHeaders headers;
  158.                 Stream requestStream;
  159.                 SerializeMessage(msg, out headers, out requestStream);
  160.                
  161.                 // process message
  162.                 Stream returnStream;
  163.                 ITransportHeaders returnHeaders;
  164.                 _nextSink.ProcessMessage(msg, headers, requestStream, out returnHeaders, out returnStream);
  165.                 if (returnHeaders == null)
  166.                     throw new ArgumentNullException("returnHeaders");
  167.                
  168.                 // deserialize stream
  169.                 retMsg = DeserializeMessage(mcm, returnHeaders, returnStream);
  170.             }
  171.             catch (Exception e) {
  172.                 retMsg = new ReturnMessage(e, mcm);
  173.             }
  174.             catch {
  175.                 retMsg = new ReturnMessage(new Exception(CoreChannel.GetResourceString("Remoting_nonClsCompliantException")), mcm);
  176.             }
  177.            
  178.             return retMsg;
  179.         }
  180.         // SyncProcessMessage
  181.        
  182.         [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure, Infrastructure = true)]
  183.         public IMessageCtrl AsyncProcessMessage(IMessage msg, IMessageSink replySink)
  184.         {
  185.             IMethodCallMessage mcm = (IMethodCallMessage)msg;
  186.             IMessage retMsg;
  187.            
  188.             try {
  189.                 // serialize message
  190.                 ITransportHeaders headers;
  191.                 Stream requestStream;
  192.                 SerializeMessage(msg, out headers, out requestStream);
  193.                
  194.                 // process message
  195.                 ClientChannelSinkStack sinkStack = new ClientChannelSinkStack(replySink);
  196.                 sinkStack.Push(this, msg);
  197.                 _nextSink.AsyncProcessRequest(sinkStack, msg, headers, requestStream);
  198.             }
  199.             catch (Exception e) {
  200.                 retMsg = new ReturnMessage(e, mcm);
  201.                 if (replySink != null)
  202.                     replySink.SyncProcessMessage(retMsg);
  203.             }
  204.             catch {
  205.                 retMsg = new ReturnMessage(new Exception(CoreChannel.GetResourceString("Remoting_nonClsCompliantException")), mcm);
  206.                 if (replySink != null)
  207.                     replySink.SyncProcessMessage(retMsg);
  208.             }
  209.            
  210.             return null;
  211.         }
  212.         // AsyncProcessMessage
  213.        
  214.         // helper function to serialize the message
  215.         private void SerializeMessage(IMessage msg, out ITransportHeaders headers, out Stream stream)
  216.         {
  217.             BaseTransportHeaders requestHeaders = new BaseTransportHeaders();
  218.             headers = requestHeaders;
  219.            
  220.             // add other http soap headers
  221.             requestHeaders.ContentType = CoreChannel.BinaryMimeType;
  222.             if (_channelProtocol == SinkChannelProtocol.Http)
  223.                 headers["__RequestVerb"] = "POST";
  224.            
  225.             bool bMemStream = false;
  226.             stream = _nextSink.GetRequestStream(msg, headers);
  227.             if (stream == null) {
  228.                 stream = new ChunkedMemoryStream(CoreChannel.BufferPool);
  229.                 bMemStream = true;
  230.             }
  231.             CoreChannel.SerializeBinaryMessage(msg, stream, _includeVersioning);
  232.             if (bMemStream)
  233.                 stream.Position = 0;
  234.         }
  235.         // SerializeMessage
  236.        
  237.         // helper function to deserialize the message
  238.         private IMessage DeserializeMessage(IMethodCallMessage mcm, ITransportHeaders headers, Stream stream)
  239.         {
  240.             // deserialize the message
  241.             IMessage retMsg = CoreChannel.DeserializeBinaryResponseMessage(stream, mcm, _strictBinding);
  242.            
  243.             stream.Close();
  244.             return retMsg;
  245.         }
  246.         // DeserializeMessage
  247.        
  248.         //
  249.         // IClientChannelSink implementation
  250.         //
  251.        
  252.         [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure, Infrastructure = true)]
  253.         public void ProcessMessage(IMessage msg, ITransportHeaders requestHeaders, Stream requestStream, out ITransportHeaders responseHeaders, out Stream responseStream)
  254.         {
  255.             // should never gets called, since this sink is always first
  256.             throw new NotSupportedException();
  257.         }
  258.         // ProcessMessage
  259.        
  260.         [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure, Infrastructure = true)]
  261.         public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream stream)
  262.         {
  263.             // should never be called, this sink is always first
  264.             throw new NotSupportedException();
  265.         }
  266.         // AsyncProcessRequest
  267.        
  268.         [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure, Infrastructure = true)]
  269.         public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream)
  270.         {
  271.             // previously we stored the outgoing message in state
  272.             IMethodCallMessage mcm = (IMethodCallMessage)state;
  273.             IMessage retMsg = DeserializeMessage(mcm, headers, stream);
  274.             sinkStack.DispatchReplyMessage(retMsg);
  275.         }
  276.         // AsyncProcessRequest
  277.        
  278.         [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure, Infrastructure = true)]
  279.         public Stream GetRequestStream(IMessage msg, ITransportHeaders headers)
  280.         {
  281.             // never called on formatter sender sink
  282.             throw new NotSupportedException();
  283.         }
  284.        
  285.        
  286.         public IClientChannelSink NextChannelSink {
  287.             [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure, Infrastructure = true)]
  288.             get { return _nextSink; }
  289.         }
  290.        
  291.        
  292.         public IDictionary Properties {
  293.             [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure, Infrastructure = true)]
  294.             get { return null; }
  295.         }
  296.         // Properties
  297.         //
  298.         // end of IClientChannelSink implementation
  299.         //
  300.        
  301.     }
  302.     // class BinaryClientFormatterSink
  303.    
  304.    
  305.     //
  306.     // SERVER-SIDE SOAP FORMATTER SINKS
  307.     //
  308.    
  309.     public class BinaryServerFormatterSinkProvider : IServerFormatterSinkProvider
  310.     {
  311.         private IServerChannelSinkProvider _next = null;
  312.        
  313.         // settings from config
  314.         private bool _includeVersioning = true;
  315.         private bool _strictBinding = false;
  316.         private TypeFilterLevel _formatterSecurityLevel = TypeFilterLevel.Low;
  317.        
  318.         public BinaryServerFormatterSinkProvider()
  319.         {
  320.         }
  321.         // BinaryServerFormatterSinkProvider
  322.        
  323.         public BinaryServerFormatterSinkProvider(IDictionary properties, ICollection providerData)
  324.         {
  325.             // look at properties
  326.             if (properties != null) {
  327.                 foreach (DictionaryEntry entry in properties) {
  328.                     string keyStr = entry.Key.ToString();
  329.                     switch (keyStr) {
  330.                         case "includeVersions":
  331.                             _includeVersioning = Convert.ToBoolean(entry.Value, CultureInfo.InvariantCulture);
  332.                             break;
  333.                         case "strictBinding":
  334.                             _strictBinding = Convert.ToBoolean(entry.Value, CultureInfo.InvariantCulture);
  335.                             break;
  336.                         case "typeFilterLevel":
  337.                             _formatterSecurityLevel = (TypeFilterLevel)Enum.Parse(typeof(TypeFilterLevel), (string)entry.Value);
  338.                             break;
  339.                         default:
  340.                            
  341.                             break;
  342.                     }
  343.                 }
  344.             }
  345.            
  346.             // not expecting any provider data
  347.             CoreChannel.VerifyNoProviderData(this.GetType().Name, providerData);
  348.         }
  349.         // BinaryServerFormatterSinkProvider
  350.        
  351.         [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure, Infrastructure = true)]
  352.         public void GetChannelData(IChannelDataStore channelData)
  353.         {
  354.         }
  355.         // GetChannelData
  356.         [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure, Infrastructure = true)]
  357.         public IServerChannelSink CreateSink(IChannelReceiver channel)
  358.         {
  359.             if (null == channel) {
  360.                 throw new ArgumentNullException("channel");
  361.             }
  362.            
  363.             IServerChannelSink nextSink = null;
  364.             if (_next != null)
  365.                 nextSink = _next.CreateSink(channel);
  366.            
  367.             BinaryServerFormatterSink.Protocol protocol = BinaryServerFormatterSink.Protocol.Other;
  368.            
  369.             // see if this is an http channel
  370.             string uri = channel.GetUrlsForUri("")[0];
  371.             if (String.Compare("http", 0, uri, 0, 4, StringComparison.OrdinalIgnoreCase) == 0)
  372.                 protocol = BinaryServerFormatterSink.Protocol.Http;
  373.            
  374.             BinaryServerFormatterSink sink = new BinaryServerFormatterSink(protocol, nextSink, channel);
  375.             sink.TypeFilterLevel = _formatterSecurityLevel;
  376.             sink.IncludeVersioning = _includeVersioning;
  377.             sink.StrictBinding = _strictBinding;
  378.             return sink;
  379.         }
  380.         // CreateSink
  381.         public IServerChannelSinkProvider Next {
  382.             [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure, Infrastructure = true)]
  383.             get { return _next; }
  384.             [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure, Infrastructure = true)]
  385.             set { _next = value; }
  386.         }
  387.         // Next
  388.         [System.Runtime.InteropServices.ComVisible(false)]
  389.         public TypeFilterLevel TypeFilterLevel {
  390.             get { return _formatterSecurityLevel; }
  391.            
  392.             set { _formatterSecurityLevel = value; }
  393.         }
  394.     }
  395.     // class BinaryServerFormatterSinkProvider
  396.    
  397.     public class BinaryServerFormatterSink : IServerChannelSink
  398.     {
  399.         [Serializable()]
  400.         public enum Protocol
  401.         {
  402.             Http,
  403.             // special processing needed for http
  404.             Other
  405.         }
  406.        
  407.         private IServerChannelSink _nextSink;
  408.         // If this sink doesn't recognize, the incoming
  409.         // format then it should call the next
  410.         // sink if there is one.
  411.         private Protocol _protocol;
  412.         // remembers which protocol is being used
  413.         private IChannelReceiver _receiver;
  414.         // transport sink used to parse url
  415.         private bool _includeVersioning = true;
  416.         // should versioning be used
  417.         private bool _strictBinding = false;
  418.         // strict binding should be used
  419.         private TypeFilterLevel _formatterSecurityLevel = TypeFilterLevel.Full;
  420.         private string lastUri = null;
  421.        
  422.         public BinaryServerFormatterSink(Protocol protocol, IServerChannelSink nextSink, IChannelReceiver receiver)
  423.         {
  424.             if (receiver == null)
  425.                 throw new ArgumentNullException("receiver");
  426.            
  427.             _nextSink = nextSink;
  428.             _protocol = protocol;
  429.             _receiver = receiver;
  430.         }
  431.         // BinaryServerFormatterSinkProvider
  432.        
  433.         internal bool IncludeVersioning {
  434.             set { _includeVersioning = value; }
  435.         }
  436.         // IncludeVersioning
  437.         internal bool StrictBinding {
  438.             set { _strictBinding = value; }
  439.         }
  440.         // StrictBinding
  441.         [System.Runtime.InteropServices.ComVisible(false)]
  442.         public TypeFilterLevel TypeFilterLevel {
  443.             get { return _formatterSecurityLevel; }
  444.            
  445.             set { _formatterSecurityLevel = value; }
  446.         }
  447.        
  448.         [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure, Infrastructure = true)]
  449.         public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack, IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream, out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream)
  450.         {
  451.             if (requestMsg != null) {
  452.                 // The message has already been deserialized so delegate to the next sink.
  453.                 return _nextSink.ProcessMessage(sinkStack, requestMsg, requestHeaders, requestStream, out responseMsg, out responseHeaders, out responseStream);
  454.             }
  455.            
  456.             if (requestHeaders == null)
  457.                 throw new ArgumentNullException("requestHeaders");
  458.            
  459.             BaseTransportHeaders wkRequestHeaders = requestHeaders as BaseTransportHeaders;
  460.            
  461.             ServerProcessing processing;
  462.            
  463.             responseHeaders = null;
  464.             responseStream = null;
  465.            
  466.             string verb = null;
  467.             string contentType = null;
  468.            
  469.             bool bCanServiceRequest = true;
  470.            
  471.             // determine the content type
  472.             string contentTypeHeader = null;
  473.             if (wkRequestHeaders != null)
  474.                 contentTypeHeader = wkRequestHeaders.ContentType;
  475.             else
  476.                 contentTypeHeader = requestHeaders["Content-Type"] as string;
  477.             if (contentTypeHeader != null) {
  478.                 string charsetValue;
  479.                 HttpChannelHelper.ParseContentType(contentTypeHeader, out contentType, out charsetValue);
  480.             }
  481.            
  482.             // check to see if Content-Type matches
  483.             if ((contentType != null) && (String.CompareOrdinal(contentType, CoreChannel.BinaryMimeType) != 0)) {
  484.                 bCanServiceRequest = false;
  485.             }
  486.            
  487.             // check for http specific verbs
  488.             if (_protocol == Protocol.Http) {
  489.                 verb = (string)requestHeaders["__RequestVerb"];
  490.                 if (!verb.Equals("POST") && !verb.Equals("M-POST"))
  491.                     bCanServiceRequest = false;
  492.             }
  493.            
  494.             // either delegate or return an error message if we can't service the request
  495.             if (!bCanServiceRequest) {
  496.                 // delegate to next sink if available
  497.                 if (_nextSink != null) {
  498.                     return _nextSink.ProcessMessage(sinkStack, null, requestHeaders, requestStream, out responseMsg, out responseHeaders, out responseStream);
  499.                 }
  500.                 else {
  501.                     // send back an error message
  502.                     if (_protocol == Protocol.Http) {
  503.                         // return a client bad request error
  504.                         responseHeaders = new TransportHeaders();
  505.                         responseHeaders["__HttpStatusCode"] = "400";
  506.                         responseHeaders["__HttpReasonPhrase"] = "Bad Request";
  507.                         responseStream = null;
  508.                         responseMsg = null;
  509.                         return ServerProcessing.Complete;
  510.                     }
  511.                     else {
  512.                         // The transport sink will catch this and do something here.
  513.                         throw new RemotingException(CoreChannel.GetResourceString("Remoting_Channels_InvalidRequestFormat"));
  514.                     }
  515.                 }
  516.             }
  517.            
  518.            
  519.             try {
  520.                 string objectUri = null;
  521.                
  522.                 bool bIsCustomErrorEnabled = true;
  523.                 object oIsCustomErrorEnabled = requestHeaders["__CustomErrorsEnabled"];
  524.                 if (oIsCustomErrorEnabled != null && oIsCustomErrorEnabled is bool) {
  525.                     bIsCustomErrorEnabled = (bool)oIsCustomErrorEnabled;
  526.                 }
  527.                 CallContext.SetData("__CustomErrorsEnabled", bIsCustomErrorEnabled);
  528.                
  529.                 if (wkRequestHeaders != null)
  530.                     objectUri = wkRequestHeaders.RequestUri;
  531.                 else
  532.                     objectUri = (string)requestHeaders[CommonTransportKeys.RequestUri];
  533.                
  534.                 if (objectUri != lastUri && RemotingServices.GetServerTypeForUri(objectUri) == null)
  535.                     throw new RemotingException(CoreChannel.GetResourceString("Remoting_ChnlSink_UriNotPublished"));
  536.                 else
  537.                     lastUri = objectUri;
  538.                
  539.                 PermissionSet currentPermissionSet = null;
  540.                 if (this.TypeFilterLevel != TypeFilterLevel.Full) {
  541.                     currentPermissionSet = new PermissionSet(PermissionState.None);
  542.                     currentPermissionSet.SetPermission(new SecurityPermission(SecurityPermissionFlag.SerializationFormatter));
  543.                 }
  544.                
  545.                 try {
  546.                     if (currentPermissionSet != null)
  547.                         currentPermissionSet.PermitOnly();
  548.                    
  549.                     // Deserialize Request - Stream to IMessage
  550.                     requestMsg = CoreChannel.DeserializeBinaryRequestMessage(objectUri, requestStream, _strictBinding, this.TypeFilterLevel);
  551.                 }
  552.                 finally {
  553.                     if (currentPermissionSet != null)
  554.                         CodeAccessPermission.RevertPermitOnly();
  555.                 }
  556.                 requestStream.Close();
  557.                
  558.                 if (requestMsg == null) {
  559.                     throw new RemotingException(CoreChannel.GetResourceString("Remoting_DeserializeMessage"));
  560.                 }
  561.                
  562.                
  563.                 // Dispatch Call
  564.                 sinkStack.Push(this, null);
  565.                 processing = _nextSink.ProcessMessage(sinkStack, requestMsg, requestHeaders, null, out responseMsg, out responseHeaders, out responseStream);
  566.                 // make sure that responseStream is null
  567.                 if (responseStream != null) {
  568.                     throw new RemotingException(CoreChannel.GetResourceString("Remoting_ChnlSink_WantNullResponseStream"));
  569.                 }
  570.                
  571.                 switch (processing) {
  572.                     case ServerProcessing.Complete:
  573.                        
  574.                        
  575.                         {
  576.                             if (responseMsg == null)
  577.                                 throw new RemotingException(CoreChannel.GetResourceString("Remoting_DispatchMessage"));
  578.                            
  579.                             sinkStack.Pop(this);
  580.                            
  581.                             SerializeResponse(sinkStack, responseMsg, ref responseHeaders, out responseStream);
  582.                             break;
  583.                         }
  585.                         break;
  586.                     case ServerProcessing.OneWay:
  587.                         // case ServerProcessing.Complete
  588.                        
  589.                         {
  590.                             sinkStack.Pop(this);
  591.                             break;
  592.                         }
  594.                         break;
  595.                     case ServerProcessing.Async:
  596.                         // case ServerProcessing.OneWay:
  597.                        
  598.                         {
  599.                             sinkStack.Store(this, null);
  600.                             break;
  601.                         }
  603.                         break;
  604.                     // case ServerProcessing.Async
  605.                 }
  606.                 // switch (processing)
  607.             }
  608.             catch (Exception e) {
  609.                 processing = ServerProcessing.Complete;
  610.                 responseMsg = new ReturnMessage(e, (IMethodCallMessage)(requestMsg == null ? new ErrorMessage() : requestMsg));
  611.                 //TODO, sowmys: See if we could call SerializeResponse here
  612.                 //We always set __ClientIsClr here since interop is not an issue
  613.                 CallContext.SetData("__ClientIsClr", true);
  614.                 responseStream = (MemoryStream)CoreChannel.SerializeBinaryMessage(responseMsg, _includeVersioning);
  615.                 CallContext.FreeNamedDataSlot("__ClientIsClr");
  616.                 responseStream.Position = 0;
  617.                 responseHeaders = new TransportHeaders();
  618.                
  619.                 if (_protocol == Protocol.Http) {
  620.                     responseHeaders["Content-Type"] = CoreChannel.BinaryMimeType;
  621.                 }
  622.             }
  623.             catch {
  624.                 processing = ServerProcessing.Complete;
  625.                 responseMsg = new ReturnMessage(new Exception(CoreChannel.GetResourceString("Remoting_nonClsCompliantException")), (IMethodCallMessage)(requestMsg == null ? new ErrorMessage() : requestMsg));
  626.                 //TODO, sowmys: See if we could call SerializeResponse here
  627.                 //We always set __ClientIsClr here since interop is not an issue
  628.                 CallContext.SetData("__ClientIsClr", true);
  629.                 responseStream = (MemoryStream)CoreChannel.SerializeBinaryMessage(responseMsg, _includeVersioning);
  630.                 CallContext.FreeNamedDataSlot("__ClientIsClr");
  631.                 responseStream.Position = 0;
  632.                 responseHeaders = new TransportHeaders();
  633.                
  634.                 if (_protocol == Protocol.Http) {
  635.                     responseHeaders["Content-Type"] = CoreChannel.BinaryMimeType;
  636.                 }
  637.             }
  638.             finally {
  639.                 CallContext.FreeNamedDataSlot("__CustomErrorsEnabled");
  640.             }
  641.            
  642.             return processing;
  643.         }
  644.         // ProcessMessage
  645.        
  646.         [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure, Infrastructure = true)]
  647.         public void AsyncProcessResponse(IServerResponseChannelSinkStack sinkStack, object state, IMessage msg, ITransportHeaders headers, Stream stream)
  648.         {
  649.             SerializeResponse(sinkStack, msg, ref headers, out stream);
  650.             sinkStack.AsyncProcessResponse(msg, headers, stream);
  651.         }
  652.         // AsyncProcessResponse
  653.        
  654.         [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure, Infrastructure = true)]
  655.         private void SerializeResponse(IServerResponseChannelSinkStack sinkStack, IMessage msg, ref ITransportHeaders headers, out Stream stream)
  656.         {
  657.             BaseTransportHeaders responseHeaders = new BaseTransportHeaders();
  658.             if (headers != null) {
  659.                 // copy old headers into new headers
  660.                 foreach (DictionaryEntry entry in headers) {
  661.                     responseHeaders[entry.Key] = entry.Value;
  662.                 }
  663.             }
  664.             headers = responseHeaders;
  665.            
  666.             if (_protocol == Protocol.Http) {
  667.                 responseHeaders.ContentType = CoreChannel.BinaryMimeType;
  668.             }
  669.            
  670.             bool bMemStream = false;
  671.             stream = sinkStack.GetResponseStream(msg, headers);
  672.             if (stream == null) {
  673.                 stream = new ChunkedMemoryStream(CoreChannel.BufferPool);
  674.                 bMemStream = true;
  675.             }
  676.            
  677.             bool bBashUrl = CoreChannel.SetupUrlBashingForIisSslIfNecessary();
  678.             try {
  679.                 CallContext.SetData("__ClientIsClr", true);
  680.                 CoreChannel.SerializeBinaryMessage(msg, stream, _includeVersioning);
  681.             }
  682.             finally {
  683.                 CallContext.FreeNamedDataSlot("__ClientIsClr");
  684.                 CoreChannel.CleanupUrlBashingForIisSslIfNecessary(bBashUrl);
  685.             }
  686.            
  687.             if (bMemStream)
  688.                 stream.Position = 0;
  689.         }
  690.         // SerializeResponse
  691.        
  692.         [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure, Infrastructure = true)]
  693.         public Stream GetResponseStream