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 \ CoreChannel

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. using System;
  16. using System.Text;
  17. using System.Threading;
  18. using System.Reflection;
  19. using System.Runtime.Serialization;
  20. using System.Runtime.Serialization.Formatters;
  21. using System.Runtime.Serialization.Formatters.Soap;
  22. using System.Runtime.Serialization.Formatters.Binary;
  23. using System.Runtime.Remoting;
  24. using System.Runtime.Remoting.Channels;
  25. using System.Runtime.Remoting.Messaging;
  26. using System.Runtime.Remoting.Metadata;
  27. using System.Security.Principal;
  28. using System.ComponentModel;
  29. using System.IO;
  30. using System.Net;
  31. using System.Collections;
  32. using System.Net.Sockets;
  33. using System.Resources;
  34. using System.Diagnostics;
  35. using System.Globalization;
  36. using System.Runtime.InteropServices;
  39. namespace System.Runtime.Remoting.Channels
  40. {
  41.    
  42.     // Use this internal indicator (as opposed to the nested enum found
  43.     // on some of the server channel sinks)
  44.     internal enum SinkChannelProtocol
  45.     {
  46.         Http,
  47.         // special processing needed for http
  48.         Other
  49.     }
  50.     // ChannelProtocol
  51.    
  52.    
  53.     static internal class CoreChannel
  54.     {
  55.         private static IByteBufferPool _bufferPool = new ByteBufferPool(10, 4096);
  56.         private static RequestQueue _requestQueue = new RequestQueue(8, 4, 250);
  57.        
  58.         static internal IByteBufferPool BufferPool {
  59.             get { return _bufferPool; }
  60.         }
  61.         static internal RequestQueue RequestQueue {
  62.             get { return _requestQueue; }
  63.         }
  64.        
  65.        
  66.         internal const int MaxStringLen = 512;
  67.        
  68.         internal const string SOAPMimeType = "text/xml";
  69.         internal const string BinaryMimeType = "application/octet-stream";
  70.        
  71.         internal const string SOAPContentType = "text/xml; charset=\"utf-8\"";
  72.        
  73.         private static string s_hostName = null;
  74.         private static string s_MachineName = null;
  75.         private static string s_MachineIp = null;
  76.         private static IPAddress s_MachineIpAddress = null;
  77.         // Copy of consts defined in RemotingServices.cs
  78.         internal const int CLIENT_MSG_GEN = 1;
  79.         internal const int CLIENT_MSG_SINK_CHAIN = 2;
  80.         internal const int CLIENT_MSG_SER = 3;
  81.         internal const int CLIENT_MSG_SEND = 4;
  82.         internal const int SERVER_MSG_RECEIVE = 5;
  83.         internal const int SERVER_MSG_DESER = 6;
  84.         internal const int SERVER_MSG_SINK_CHAIN = 7;
  85.         internal const int SERVER_MSG_STACK_BUILD = 8;
  86.         internal const int SERVER_DISPATCH = 9;
  87.         internal const int SERVER_RET_STACK_BUILD = 10;
  88.         internal const int SERVER_RET_SINK_CHAIN = 11;
  89.         internal const int SERVER_RET_SER = 12;
  90.         internal const int SERVER_RET_SEND = 13;
  91.         internal const int SERVER_RET_END = 14;
  92.         internal const int CLIENT_RET_RECEIVE = 15;
  93.         internal const int CLIENT_RET_DESER = 16;
  94.         internal const int CLIENT_RET_SINK_CHAIN = 17;
  95.         internal const int CLIENT_RET_PROPAGATION = 18;
  96.         internal const int CLIENT_END_CALL = 19;
  97.         internal const int TIMING_DATA_EOF = 99;
  98.        
  99.         static internal string GetHostName()
  100.         {
  101.             if (s_hostName == null) {
  102.                 s_hostName = Dns.GetHostName();
  103.                
  104.                 if (s_hostName == null) {
  105.                     throw new ArgumentNullException("hostName");
  106.                 }
  107.             }
  108.            
  109.             return s_hostName;
  110.         }
  111.         // GetHostName
  112.         static internal string GetMachineName()
  113.         {
  114.             if (s_MachineName == null) {
  115.                 string machineName = GetHostName();
  116.                 if (machineName != null) {
  117.                     IPHostEntry host = Dns.GetHostEntry(machineName);
  118.                     if (host != null)
  119.                         s_MachineName = host.HostName;
  120.                 }
  121.                
  122.                 if (s_MachineName == null) {
  123.                     throw new ArgumentNullException("machine");
  124.                 }
  125.             }
  126.            
  127.             return s_MachineName;
  128.         }
  129.         // GetMachineName
  130.        
  131.         // This helper function Checks whether the remote IP Adress is actually a local address
  132.         static internal bool IsLocalIpAddress(IPAddress remoteAddress)
  133.         {
  134.             if (s_MachineIpAddress == null) {
  135.                 string hostName = GetMachineName();
  136.                
  137.                 // NOTE: We intentionally allow exceptions from these api's
  138.                 // propagate out to the caller.
  139.                 IPHostEntry ipEntries = Dns.GetHostEntry(hostName);
  140.                 // If there is only one entry we should cache it
  141.                 if (ipEntries != null && ipEntries.AddressList.Length == 1) {
  142.                     s_MachineIpAddress = GetMachineAddress(ipEntries, AddressFamily.InterNetwork);
  143.                 }
  144.                 else {
  145.                     return IsLocalIpAddress(ipEntries, AddressFamily.InterNetwork, remoteAddress);
  146.                 }
  147.             }
  148.             return s_MachineIpAddress.Equals(remoteAddress);
  149.         }
  150.        
  151.         //This helper function compares and IpAddress with all addresses in IpHostEntry
  152.         static internal bool IsLocalIpAddress(IPHostEntry host, AddressFamily addressFamily, IPAddress remoteAddress)
  153.         {
  154.             if (host != null) {
  155.                 IPAddress[] addressList = host.AddressList;
  156.                 for (int i = 0; i < addressList.Length; i++) {
  157.                     if (addressList[i].AddressFamily == addressFamily) {
  158.                         if (addressList[i].Equals(remoteAddress))
  159.                             return true;
  160.                     }
  161.                 }
  162.             }
  163.             return false;
  164.         }
  165.        
  166.         // process specified host name to see if it is a meta-hostname that
  167.         // should be replaced with something else.
  168.         static internal string DecodeMachineName(string machineName)
  169.         {
  170.             if (machineName.Equals("$hostName"))
  171.                 return GetHostName();
  172.            
  173.             return machineName;
  174.         }
  175.         // DecodeMachineName
  176.        
  177.         static internal string GetMachineIp()
  178.         {
  179.             if (s_MachineIp == null) {
  180.                 string hostName = GetMachineName();
  181.                
  182.                 // NOTE: We intentionally allow exceptions from these api's
  183.                 // propagate out to the caller.
  184.                 IPHostEntry ipEntries = Dns.GetHostEntry(hostName);
  185.                 IPAddress addr = GetMachineAddress(ipEntries, AddressFamily.InterNetwork);
  186.                 if (addr != null) {
  187.                     s_MachineIp = addr.ToString();
  188.                 }
  189.                
  190.                 if (s_MachineIp == null) {
  191.                     throw new ArgumentNullException("ip");
  192.                 }
  193.             }
  194.            
  195.             return s_MachineIp;
  196.         }
  197.         // GetMachineIp
  198.         // This helper function returns the first IPAddress with family 'addressFamily' from
  199.         // host.AddressList, or null if there is no such address or if host is null.
  200.         static internal IPAddress GetMachineAddress(IPHostEntry host, AddressFamily addressFamily)
  201.         {
  202.             // NOTE: We intentionally allow exceptions from these api's
  203.             // propagate out to the caller.
  204.             IPAddress result = null;
  205.             if (host != null) {
  206.                 // find the first address for this address family
  207.                 IPAddress[] addressList = host.AddressList;
  208.                 for (int i = 0; i < addressList.Length; i++) {
  209.                     if (addressList[i].AddressFamily == addressFamily) {
  210.                         result = addressList[i];
  211.                         break;
  212.                     }
  213.                 }
  214.             }
  215.            
  216.             //Console.WriteLine("GetMachineAddress(" + hostName + ", " + addressFamily + ") -> " + (result == null ? "<null>" : result.ToString()));
  217.             return result;
  218.         }
  219.         // GetMachineAddress
  220.        
  221.         //
  222.         // Core Serialization and Deserialization support
  223.         //
  224.         static internal Header[] GetMessagePropertiesAsSoapHeader(IMessage reqMsg)
  225.         {
  226.             IDictionary d = reqMsg.Properties;
  227.             if (d == null)
  228.                 return null;
  229.            
  230.             int count = d.Count;
  231.             if (count == 0)
  232.                 return null;
  233.            
  234.             IDictionaryEnumerator e = (IDictionaryEnumerator)d.GetEnumerator();
  235.            
  236.             // cycle through the headers to get a length
  237.             bool[] map = new bool[count];
  238.             int len = 0;
  239.             int i = 0;
  240.             IMethodMessage msg = (IMethodMessage)reqMsg;
  241.             while (e.MoveNext()) {
  242.                 string key = (string)e.Key;
  243.                 if ((key.Length >= 2) && (String.CompareOrdinal(key, 0, "__", 0, 2) == 0) && (key.Equals("__Args") || key.Equals("__OutArgs") || key.Equals("__Return") || key.Equals("__Uri") || key.Equals("__MethodName") || (key.Equals("__MethodSignature") && (!RemotingServices.IsMethodOverloaded(msg)) && (!msg.HasVarArgs)) || key.Equals("__TypeName") || key.Equals("__Fault") || (key.Equals("__CallContext") && ((e.Value != null) ? (((LogicalCallContext)e.Value).HasInfo == false) : true)))) {
  244.                     i++;
  245.                     continue;
  246.                 }
  247.                 map[i] = true;
  248.                 i++;
  249.                 len++;
  250.             }
  251.             if (len == 0)
  252.                 return null;
  253.            
  254.            
  255.             Header[] ret = new Header[len];
  256.             e.Reset();
  257.             int k = 0;
  258.             i = 0;
  259.             while (e.MoveNext()) {
  260.                 object key = e.Key;
  261.                 if (!map[k]) {
  262.                     k++;
  263.                     continue;
  264.                 }
  265.                
  266.                 Header h = e.Value as Header;
  267.                
  268.                 // If the property is not a header, then make a header out of it.
  269.                 if (h == null) {
  270.                     h = new Header((string)key, e.Value, false, "http://schemas.microsoft.com/clr/soap/messageProperties");
  271.                 }
  272.                
  273.                 if (i == ret.Length) {
  274.                     InternalRemotingServices.RemotingTrace("HTTPChannel::GetHeaders creating a new array of length " + (i + 1) + "\n");
  275.                     Header[] newret = new Header[i + 1];
  276.                     Array.Copy(ret, newret, i);
  277.                     ret = newret;
  278.                 }
  279.                 ret[i] = h;
  280.                 i++;
  281.                 k++;
  282.             }
  283.            
  284.             return ret;
  285.         }
  286.         // GetMessagePropertiesAsSoapHeader
  287.        
  288.         static internal Header[] GetSoapHeaders(IMessage reqMsg)
  289.         {
  290.             // If there are message properties, we'll need to resize the header array.
  291.             Header[] msgProperties = GetMessagePropertiesAsSoapHeader(reqMsg);
  292.            
  293.             return msgProperties;
  294.         }
  295.         // GetSoapHeaders
  296.        
  297.        
  298.         static internal SoapFormatter CreateSoapFormatter(bool serialize, bool includeVersions)
  299.         {
  300.             SoapFormatter remotingFormatter = new SoapFormatter();
  301.            
  302.             if (serialize) {
  303.                 RemotingSurrogateSelector rss = new RemotingSurrogateSelector();
  304.                 remotingFormatter.SurrogateSelector = rss;
  305.                 rss.UseSoapFormat();
  306.             }
  307.             else
  308.                 remotingFormatter.SurrogateSelector = null;
  309.            
  310.             remotingFormatter.Context = new StreamingContext(StreamingContextStates.Other);
  311.            
  312.             remotingFormatter.AssemblyFormat = includeVersions ? FormatterAssemblyStyle.Full : FormatterAssemblyStyle.Simple;
  313.            
  314.             return remotingFormatter;
  315.         }
  316.         // CreateSoapFormatter
  317.        
  318.         static internal BinaryFormatter CreateBinaryFormatter(bool serialize, bool includeVersionsOrStrictBinding)
  319.         {
  320.             BinaryFormatter remotingFormatter = new BinaryFormatter();
  321.            
  322.             if (serialize) {
  323.                 RemotingSurrogateSelector rss = new RemotingSurrogateSelector();
  324.                 remotingFormatter.SurrogateSelector = rss;
  325.             }
  326.             else {
  327.                 remotingFormatter.SurrogateSelector = null;
  328.             }
  329.            
  330.             remotingFormatter.Context = new StreamingContext(StreamingContextStates.Other);
  331.            
  332.             remotingFormatter.AssemblyFormat = includeVersionsOrStrictBinding ? FormatterAssemblyStyle.Full : FormatterAssemblyStyle.Simple;
  333.            
  334.             return remotingFormatter;
  335.         }
  336.         // CreateBinaryFormatter
  337.        
  338.        
  339.        
  340.         static internal void SerializeSoapMessage(IMessage msg, Stream outputStream, bool includeVersions)
  341.         {
  342.             // create soap formatter
  343.             SoapFormatter fmt = CreateSoapFormatter(true, includeVersions);
  344.            
  345.             //check for special options if this is the SoapFormatter
  346.             IMethodMessage methodMsg = msg as IMethodMessage;
  347.             if (methodMsg != null) {
  348.                 MethodBase mb = methodMsg.MethodBase;
  349.                 if (mb != null) {
  350.                     Type type = methodMsg.MethodBase.DeclaringType;
  351.                     SoapTypeAttribute cache = (SoapTypeAttribute)InternalRemotingServices.GetCachedSoapAttribute(type);
  352.                     if ((cache.SoapOptions & SoapOption.AlwaysIncludeTypes) == SoapOption.AlwaysIncludeTypes)
  353.                         fmt.TypeFormat |= FormatterTypeStyle.TypesAlways;
  354.                     if ((cache.SoapOptions & SoapOption.XsdString) == SoapOption.XsdString)
  355.                         fmt.TypeFormat |= FormatterTypeStyle.XsdString;
  356.                 }
  357.             }
  358.             // end of set special options for SoapFormatter
  359.            
  360.             Header[] h = GetSoapHeaders(msg);
  361.            
  362.             // this is to make messages within a message serialize correctly
  363.             // and not use the fake type
  364.             ((RemotingSurrogateSelector)fmt.SurrogateSelector).SetRootObject(msg);
  365.             fmt.Serialize(outputStream, msg, h);
  366.         }
  367.         // SerializeSoapMessage
  368.         static internal Stream SerializeSoapMessage(IMessage msg, bool includeVersions)
  369.         {
  370.             MemoryStream memStream = new MemoryStream();
  371.             SerializeSoapMessage(msg, memStream, includeVersions);
  372.             memStream.Position = 0;
  373.             return memStream;
  374.         }
  375.         // SerializeSoapMessage
  376.        
  377.        
  378.         static internal void SerializeBinaryMessage(IMessage msg, Stream outputStream, bool includeVersions)
  379.         {
  380.             // create binary formatter
  381.             BinaryFormatter fmt = CreateBinaryFormatter(true, includeVersions);
  382.            
  383.             // WE SHOULD NOT CALL GetHeaders() here. The BinaryFormatter does special
  384.             // serialization for any headers that might be present.
  385.            
  386.             fmt.Serialize(outputStream, msg, null);
  387.         }
  388.         // SerializeBinaryMessage
  389.         static internal Stream SerializeBinaryMessage(IMessage msg, bool includeVersions)
  390.         {
  391.             MemoryStream memStream = new MemoryStream();
  392.             SerializeBinaryMessage(msg, memStream, includeVersions);
  393.             memStream.Position = 0;
  394.             return memStream;
  395.         }
  396.         // SerializeBinaryMessage
  397.        
  398.        
  399.         // class used to pass uri into binary serializer, so that the message
  400.         // gets the object uri.
  401.         private class UriHeaderHandler
  402.         {
  403.             string _uri = null;
  404.            
  405.             internal UriHeaderHandler(string uri)
  406.             {
  407.                 _uri = uri;
  408.             }
  409.            
  410.             public object HeaderHandler(Header[] Headers)
  411.             {
  412.                 return _uri;
  413.             }
  414.            
  415.         }
  416.         // classUriHeaderHandler
  417.        
  418.         static internal IMessage DeserializeSoapRequestMessage(Stream inputStream, Header[] h, bool bStrictBinding, TypeFilterLevel securityLevel)
  419.         {
  420.             SoapFormatter fmt = CreateSoapFormatter(false, bStrictBinding);
  421.             fmt.FilterLevel = securityLevel;
  422.            
  423.             MethodCall mc = new MethodCall(h);
  424.             fmt.Deserialize(inputStream, new HeaderHandler(mc.HeaderHandler));
  425.            
  426.             IMessage resMessage = (IMessage)mc;
  427.            
  428.             return resMessage;
  429.         }
  430.         // DeserializeSoapRequestMessage
  431.        
  432.         static internal IMessage DeserializeSoapResponseMessage(Stream inputStream, IMessage requestMsg, Header[] h, bool bStrictBinding)
  433.         {
  434.             SoapFormatter fmt = CreateSoapFormatter(false, bStrictBinding);
  435.            
  436.             IMethodCallMessage mcm = (IMethodCallMessage)requestMsg;
  437.             MethodResponse mr = new MethodResponse(h, mcm);
  438.             fmt.Deserialize(inputStream, new HeaderHandler(mr.HeaderHandler));
  439.            
  440.             IMessage resMessage = (IMessage)mr;
  441.            
  442.             return resMessage;
  443.         }
  444.         // DeserializeSoapResponseMessage
  445.        
  446.         static internal IMessage DeserializeBinaryRequestMessage(string objectUri, Stream inputStream, bool bStrictBinding, TypeFilterLevel securityLevel)
  447.         {
  448.             BinaryFormatter fmt = CreateBinaryFormatter(false, bStrictBinding);
  449.             fmt.FilterLevel = securityLevel;
  450.            
  451.             UriHeaderHandler uriHH = new UriHeaderHandler(objectUri);
  452.            
  453.             IMessage reqMsg = (IMessage)fmt.UnsafeDeserialize(inputStream, new HeaderHandler(uriHH.HeaderHandler));
  454.            
  455.             return reqMsg;
  456.         }
  457.         // DeserializeBinaryRequestMessage
  458.        
  459.         static internal IMessage DeserializeBinaryResponseMessage(Stream inputStream, IMethodCallMessage reqMsg, bool bStrictBinding)
  460.         {
  461.             BinaryFormatter fmt = CreateBinaryFormatter(false, bStrictBinding);
  462.            
  463.             IMessage replyMsg = (IMessage)fmt.UnsafeDeserializeMethodResponse(inputStream, null, reqMsg);
  464.             return replyMsg;
  465.         }
  466.         // DeserializeBinaryResponseMessage
  467.         static internal Stream SerializeMessage(string mimeType, IMessage msg, bool includeVersions)
  468.         {
  469.             Stream returnStream = new MemoryStream();
  470.             SerializeMessage(mimeType, msg, returnStream, includeVersions);
  471.             returnStream.Position = 0;
  472.             return returnStream;
  473.         }
  474.         // SerializeMessage
  475.        
  476.         static internal void SerializeMessage(string mimeType, IMessage msg, Stream outputStream, bool includeVersions)
  477.         {
  478.             InternalRemotingServices.RemotingTrace("SerializeMessage");
  479.             InternalRemotingServices.RemotingTrace("MimeType: " + mimeType);
  480.             CoreChannel.DebugMessage(msg);
  481.            
  482.             if (string.Compare(mimeType, SOAPMimeType, StringComparison.Ordinal) == 0) {
  483.                 SerializeSoapMessage(msg, outputStream, includeVersions);
  484.             }
  485.             else if (string.Compare(mimeType, BinaryMimeType, StringComparison.Ordinal) == 0) {
  486.                 SerializeBinaryMessage(msg, outputStream, includeVersions);
  487.             }
  488.            
  489.             InternalRemotingServices.RemotingTrace("SerializeMessage: OUT");
  490.         }
  491.         // SerializeMessage
  492.        
  493.        
  494.        
  495.         static internal IMessage DeserializeMessage(string mimeType, Stream xstm, bool methodRequest, IMessage msg)
  496.         {
  497.             return DeserializeMessage(mimeType, xstm, methodRequest, msg, null);
  498.         }
  499.        
  500.         static internal IMessage DeserializeMessage(string mimeType, Stream xstm, bool methodRequest, IMessage msg, Header[] h)
  501.         {
  502.             InternalRemotingServices.RemotingTrace("DeserializeMessage");
  503.             InternalRemotingServices.RemotingTrace("MimeType: " + mimeType);
  504.            
  505.             CoreChannel.DebugOutXMLStream(xstm, "Deserializing");
  506.            
  507.             Stream fmtStm = null;
  508.            
  509.             bool bin64encode = false;
  510.             bool doHeaderBodyAsOne = true;
  511.            
  512.             if (string.Compare(mimeType, BinaryMimeType, StringComparison.Ordinal) == 0) {
  513.                 doHeaderBodyAsOne = true;
  514.             }
  515.            
  516.             if (string.Compare(mimeType, SOAPMimeType, StringComparison.Ordinal) == 0) {
  517.                 doHeaderBodyAsOne = false;
  518.             }
  519.            
  520.             if (bin64encode == false) {
  521.                 fmtStm = xstm;
  522.             }
  523.             else {
  524.                 InternalRemotingServices.RemotingTrace("***************** Before base64 decode *****");
  525.                
  526.                 long Position = xstm.Position;
  527.                 MemoryStream inStm = (MemoryStream)xstm;
  528.                 byte[] byteArray = inStm.ToArray();
  529.                 xstm.Position = Position;
  530.                
  531.                 string base64String = Encoding.ASCII.GetString(byteArray, 0, byteArray.Length);
  532.                
  533.                 byte[] byteArrayContent = Convert.FromBase64String(base64String);
  534.                
  535.                 MemoryStream memStm = new MemoryStream(byteArrayContent);
  536.                
  537.                 fmtStm = memStm;
  538.                 InternalRemotingServices.RemotingTrace("***************** after base64 decode *****");
  539.             }
  540.            
  541.             object ret;
  542.             IRemotingFormatter fmt = MimeTypeToFormatter(mimeType, false);
  543.            
  544.             if (doHeaderBodyAsOne == true) {
  545.                 ret = ((BinaryFormatter)fmt).UnsafeDeserializeMethodResponse(fmtStm, null, (IMethodCallMessage)msg);
  546.             }
  547.             else {
  548.                 InternalRemotingServices.RemotingTrace("Content");
  549.                 InternalRemotingServices.RemotingTrace("***************** Before Deserialize Headers *****");
  550.                
  551.                 InternalRemotingServices.RemotingTrace("***************** After Deserialize Headers *****");
  552.                
  553.                 InternalRemotingServices.RemotingTrace("***************** Before Deserialize Message *****");
  554.                
  555.                 if (methodRequest == true) {
  556.                     MethodCall mc = new MethodCall(h);
  557.                     InternalRemotingServices.RemotingTrace("***************** Before Deserialize Message - as MethodCall *****");
  558.                     fmt.Deserialize(fmtStm, new HeaderHandler(mc.HeaderHandler));
  559.                     ret = mc;
  560.                 }
  561.                 else {
  562.                     IMethodCallMessage mcm = (IMethodCallMessage)msg;
  563.                     MethodResponse mr = new MethodResponse(h, mcm);
  564.                     InternalRemotingServices.RemotingTrace("***************** Before Deserialize Message - as MethodResponse *****");
  565.                     fmt.Deserialize(fmtStm, new HeaderHandler(mr.HeaderHandler));
  566.                     ret = mr;
  567.                 }
  568.                
  569.                 InternalRemotingServices.RemotingTrace("***************** After Deserialize Message *****");
  570.             }
  571.            
  572.             // Workaround to make this method verifiable
  573.             IMessage resMessage = (IMessage)ret;
  574.            
  575.             InternalRemotingServices.RemotingTrace("CoreChannel::DeserializeMessage OUT");
  576.             CoreChannel.DebugMessage(resMessage);
  577.            
  578.             return resMessage;
  579.         }
  580.        
  581.        
  582.        
  583.         static internal IRemotingFormatter MimeTypeToFormatter(string mimeType, bool serialize)
  584.         {
  585.             InternalRemotingServices.RemotingTrace("MimeTypeToFormatter: mimeType: " + mimeType);
  586.            
  587.             if (string.Compare(mimeType, SOAPMimeType, StringComparison.Ordinal) == 0) {
  588.                 return CreateSoapFormatter(serialize, true);
  589.             }
  590.             else if (string.Compare(mimeType, BinaryMimeType, StringComparison.Ordinal) == 0) {
  591.                 return CreateBinaryFormatter(serialize, true);
  592.             }
  593.            
  594.             return null;
  595.         }
  596.         // MimeTypeToFormatter
  597.        
  598.         //
  599.         // Other helper methods
  600.         //
  601.        
  602.         // Removes application name from front of uri if present.
  603.         static internal string RemoveApplicationNameFromUri(string uri)
  604.         {
  605.             if (uri == null)
  606.                 return null;
  607.            
  608.             string appName = RemotingConfiguration.ApplicationName;
  609.             if ((appName == null) || (appName.Length == 0))
  610.                 return uri;
  611.            
  612.             // uri must be longer than the appname plus a slash (hence the "+2")
  613.             if (uri.Length < (appName.Length + 2))
  614.                 return uri;
  615.            
  616.             // case-insensitively determine if uri starts with app name
  617.             if (String.Compare(appName, 0, uri, 0, appName.Length, StringComparison.OrdinalIgnoreCase) == 0) {
  618.                 // make sure a slash follows the app name (we already made sure
  619.                 // uri was long enough above)
  620.                 if (uri[appName.Length] == '/') {
  621.                     uri = uri.Substring(appName.Length + 1);
  622.                 }
  623.             }
  624.            
  625.             return uri;
  626.         }
  627.         // RemoveApplicationNameFromUri
  628.        
  629.         static internal void AppendProviderToClientProviderChain(IClientChannelSinkProvider providerChain, IClientChannelSinkProvider provider)
  630.         {
  631.             if (providerChain == null)
  632.                 throw new ArgumentNullException("providerChain");
  633.            
  634.             // walk to last provider in chain
  635.             while (providerChain.Next != null) {
  636.                 providerChain = providerChain.Next;
  637.             }
  638.            
  639.             providerChain.Next = provider;
  640.         }
  641.         // AppendProviderToClientProviderChain
  642.         static internal void CollectChannelDataFromServerSinkProviders(ChannelDataStore channelData, IServerChannelSinkProvider provider)
  643.         {
  644.             // walk chain and ask each provider for channel data
  645.             while (provider != null) {
  646.                 provider.GetChannelData(channelData);
  647.                
  648.                 provider = provider.Next;
  649.             }
  650.         }
  651.         // CollectChannelDataFromServerSinkProviders
  652.        
  653.         // called by providers that aren't expecting custom provider data
  654.         static internal void VerifyNoProviderData(string providerTypeName, ICollection providerData)
  655.         {