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

  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;
  37. namespace System.Runtime.Remoting.Channels
  38. {
  39.    
  40.     // Use this internal indicator (as opposed to the nested enum found
  41.     // on some of the server channel sinks)
  42.     internal enum SinkChannelProtocol
  43.     {
  44.         Http,
  45.         // special processing needed for http
  46.         Other
  47.     }
  48.     // ChannelProtocol
  49.    
  50.    
  51.     static internal class CoreChannel
  52.     {
  53.         private static IByteBufferPool _bufferPool = new ByteBufferPool(10, 4096);
  54.         private static RequestQueue _requestQueue = new RequestQueue(8, 4, 250);
  55.        
  56.         static internal IByteBufferPool BufferPool {
  57.             get { return _bufferPool; }
  58.         }
  59.         static internal RequestQueue RequestQueue {
  60.             get { return _requestQueue; }
  61.         }
  62.        
  63.        
  64.         internal const int MaxStringLen = 512;
  65.        
  66.         internal const string SOAPMimeType = "text/xml";
  67.         internal const string BinaryMimeType = "application/octet-stream";
  68.        
  69.         internal const string SOAPContentType = "text/xml; charset=\"utf-8\"";
  70.        
  71.         private static string s_hostName = null;
  72.         private static string s_MachineName = null;
  73.         private static string s_MachineIp = null;
  74.         private static IPAddress s_MachineIpAddress = null;
  75.         // Copy of consts defined in RemotingServices.cs
  76.         internal const int CLIENT_MSG_GEN = 1;
  77.         internal const int CLIENT_MSG_SINK_CHAIN = 2;
  78.         internal const int CLIENT_MSG_SER = 3;
  79.         internal const int CLIENT_MSG_SEND = 4;
  80.         internal const int SERVER_MSG_RECEIVE = 5;
  81.         internal const int SERVER_MSG_DESER = 6;
  82.         internal const int SERVER_MSG_SINK_CHAIN = 7;
  83.         internal const int SERVER_MSG_STACK_BUILD = 8;
  84.         internal const int SERVER_DISPATCH = 9;
  85.         internal const int SERVER_RET_STACK_BUILD = 10;
  86.         internal const int SERVER_RET_SINK_CHAIN = 11;
  87.         internal const int SERVER_RET_SER = 12;
  88.         internal const int SERVER_RET_SEND = 13;
  89.         internal const int SERVER_RET_END = 14;
  90.         internal const int CLIENT_RET_RECEIVE = 15;
  91.         internal const int CLIENT_RET_DESER = 16;
  92.         internal const int CLIENT_RET_SINK_CHAIN = 17;
  93.         internal const int CLIENT_RET_PROPAGATION = 18;
  94.         internal const int CLIENT_END_CALL = 19;
  95.         internal const int TIMING_DATA_EOF = 99;
  96.        
  97.         static internal string GetHostName()
  98.         {
  99.             if (s_hostName == null) {
  100.                 s_hostName = Dns.GetHostName();
  101.                
  102.                 if (s_hostName == null) {
  103.                     throw new ArgumentNullException("hostName");
  104.                 }
  105.             }
  106.            
  107.             return s_hostName;
  108.         }
  109.         // GetHostName
  110.         static internal string GetMachineName()
  111.         {
  112.             if (s_MachineName == null) {
  113.                 string machineName = GetHostName();
  114.                 if (machineName != null) {
  115.                     IPHostEntry host = Dns.GetHostEntry(machineName);
  116.                     if (host != null)
  117.                         s_MachineName = host.HostName;
  118.                 }
  119.                
  120.                 if (s_MachineName == null) {
  121.                     throw new ArgumentNullException("machine");
  122.                 }
  123.             }
  124.            
  125.             return s_MachineName;
  126.         }
  127.         // GetMachineName
  128.        
  129.         // This helper function Checks whether the remote IP Adress is actually a local address
  130.         static internal bool IsLocalIpAddress(IPAddress remoteAddress)
  131.         {
  132.             if (s_MachineIpAddress == null) {
  133.                 string hostName = GetMachineName();
  134.                
  135.                 // NOTE: We intentionally allow exceptions from these api's
  136.                 // propagate out to the caller.
  137.                 IPHostEntry ipEntries = Dns.GetHostEntry(hostName);
  138.                 // If there is only one entry we should cache it
  139.                 if (ipEntries != null && ipEntries.AddressList.Length == 1) {
  140.                     s_MachineIpAddress = GetMachineAddress(ipEntries, AddressFamily.InterNetwork);
  141.                 }
  142.                 else {
  143.                     return IsLocalIpAddress(ipEntries, AddressFamily.InterNetwork, remoteAddress);
  144.                 }
  145.             }
  146.             return s_MachineIpAddress.Equals(remoteAddress);
  147.         }
  148.        
  149.         //This helper function compares and IpAddress with all addresses in IpHostEntry
  150.         static internal bool IsLocalIpAddress(IPHostEntry host, AddressFamily addressFamily, IPAddress remoteAddress)
  151.         {
  152.             if (host != null) {
  153.                 IPAddress[] addressList = host.AddressList;
  154.                 for (int i = 0; i < addressList.Length; i++) {
  155.                     if (addressList[i].AddressFamily == addressFamily) {
  156.                         if (addressList[i].Equals(remoteAddress))
  157.                             return true;
  158.                     }
  159.                 }
  160.             }
  161.             return false;
  162.         }
  163.        
  164.         // process specified host name to see if it is a meta-hostname that
  165.         // should be replaced with something else.
  166.         static internal string DecodeMachineName(string machineName)
  167.         {
  168.             if (machineName.Equals("$hostName"))
  169.                 return GetHostName();
  170.            
  171.             return machineName;
  172.         }
  173.         // DecodeMachineName
  174.        
  175.         static internal string GetMachineIp()
  176.         {
  177.             if (s_MachineIp == null) {
  178.                 string hostName = GetMachineName();
  179.                
  180.                 // NOTE: We intentionally allow exceptions from these api's
  181.                 // propagate out to the caller.
  182.                 IPHostEntry ipEntries = Dns.GetHostEntry(hostName);
  183.                 IPAddress addr = GetMachineAddress(ipEntries, AddressFamily.InterNetwork);
  184.                 if (addr != null) {
  185.                     s_MachineIp = addr.ToString();
  186.                 }
  187.                
  188.                 if (s_MachineIp == null) {
  189.                     throw new ArgumentNullException("ip");
  190.                 }
  191.             }
  192.            
  193.             return s_MachineIp;
  194.         }
  195.         // GetMachineIp
  196.         // This helper function returns the first IPAddress with family 'addressFamily' from
  197.         // host.AddressList, or null if there is no such address or if host is null.
  198.         static internal IPAddress GetMachineAddress(IPHostEntry host, AddressFamily addressFamily)
  199.         {
  200.             // NOTE: We intentionally allow exceptions from these api's
  201.             // propagate out to the caller.
  202.             IPAddress result = null;
  203.             if (host != null) {
  204.                 // find the first address for this address family
  205.                 IPAddress[] addressList = host.AddressList;
  206.                 for (int i = 0; i < addressList.Length; i++) {
  207.                     if (addressList[i].AddressFamily == addressFamily) {
  208.                         result = addressList[i];
  209.                         break;
  210.                     }
  211.                 }
  212.             }
  213.            
  214.             //Console.WriteLine("GetMachineAddress(" + hostName + ", " + addressFamily + ") -> " + (result == null ? "<null>" : result.ToString()));
  215.             return result;
  216.         }
  217.         // GetMachineAddress
  218.        
  219.         //
  220.         // Core Serialization and Deserialization support
  221.         //
  222.         static internal Header[] GetMessagePropertiesAsSoapHeader(IMessage reqMsg)
  223.         {
  224.             IDictionary d = reqMsg.Properties;
  225.             if (d == null)
  226.                 return null;
  227.            
  228.             int count = d.Count;
  229.             if (count == 0)
  230.                 return null;
  231.            
  232.             IDictionaryEnumerator e = (IDictionaryEnumerator)d.GetEnumerator();
  233.            
  234.             // cycle through the headers to get a length
  235.             bool[] map = new bool[count];
  236.             int len = 0;
  237.             int i = 0;
  238.             IMethodMessage msg = (IMethodMessage)reqMsg;
  239.             while (e.MoveNext()) {
  240.                 string key = (string)e.Key;
  241.                 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)))) {
  242.                     i++;
  243.                     continue;
  244.                 }
  245.                 map[i] = true;
  246.                 i++;
  247.                 len++;
  248.             }
  249.             if (len == 0)
  250.                 return null;
  251.            
  252.            
  253.             Header[] ret = new Header[len];
  254.             e.Reset();
  255.             int k = 0;
  256.             i = 0;
  257.             while (e.MoveNext()) {
  258.                 object key = e.Key;
  259.                 if (!map[k]) {
  260.                     k++;
  261.                     continue;
  262.                 }
  263.                
  264.                 Header h = e.Value as Header;
  265.                
  266.                 // If the property is not a header, then make a header out of it.
  267.                 if (h == null) {
  268.                     h = new Header((string)key, e.Value, false, "http://schemas.microsoft.com/clr/soap/messageProperties");
  269.                 }
  270.                
  271.                 if (i == ret.Length) {
  272.                     InternalRemotingServices.RemotingTrace("HTTPChannel::GetHeaders creating a new array of length " + (i + 1) + "\n");
  273.                     Header[] newret = new Header[i + 1];
  274.                     Array.Copy(ret, newret, i);
  275.                     ret = newret;
  276.                 }
  277.                 ret[i] = h;
  278.                 i++;
  279.                 k++;
  280.             }
  281.            
  282.             return ret;
  283.         }
  284.         // GetMessagePropertiesAsSoapHeader
  285.        
  286.         static internal Header[] GetSoapHeaders(IMessage reqMsg)
  287.         {
  288.             // If there are message properties, we'll need to resize the header array.
  289.             Header[] msgProperties = GetMessagePropertiesAsSoapHeader(reqMsg);
  290.            
  291.             return msgProperties;
  292.         }
  293.         // GetSoapHeaders
  294.        
  295.        
  296.         static internal SoapFormatter CreateSoapFormatter(bool serialize, bool includeVersions)
  297.         {
  298.             SoapFormatter remotingFormatter = new SoapFormatter();
  299.            
  300.             if (serialize) {
  301.                 RemotingSurrogateSelector rss = new RemotingSurrogateSelector();
  302.                 remotingFormatter.SurrogateSelector = rss;
  303.                 rss.UseSoapFormat();
  304.             }
  305.             else
  306.                 remotingFormatter.SurrogateSelector = null;
  307.            
  308.             remotingFormatter.Context = new StreamingContext(StreamingContextStates.Other);
  309.            
  310.             remotingFormatter.AssemblyFormat = includeVersions ? FormatterAssemblyStyle.Full : FormatterAssemblyStyle.Simple;
  311.            
  312.             return remotingFormatter;
  313.         }
  314.         // CreateSoapFormatter
  315.        
  316.         static internal BinaryFormatter CreateBinaryFormatter(bool serialize, bool includeVersionsOrStrictBinding)
  317.         {
  318.             BinaryFormatter remotingFormatter = new BinaryFormatter();
  319.            
  320.             if (serialize) {
  321.                 RemotingSurrogateSelector rss = new RemotingSurrogateSelector();
  322.                 remotingFormatter.SurrogateSelector = rss;
  323.             }
  324.             else {
  325.                 remotingFormatter.SurrogateSelector = null;
  326.             }
  327.            
  328.             remotingFormatter.Context = new StreamingContext(StreamingContextStates.Other);
  329.            
  330.             remotingFormatter.AssemblyFormat = includeVersionsOrStrictBinding ? FormatterAssemblyStyle.Full : FormatterAssemblyStyle.Simple;
  331.            
  332.             return remotingFormatter;
  333.         }
  334.         // CreateBinaryFormatter
  335.        
  336.        
  337.        
  338.         static internal void SerializeSoapMessage(IMessage msg, Stream outputStream, bool includeVersions)
  339.         {
  340.             // create soap formatter
  341.             SoapFormatter fmt = CreateSoapFormatter(true, includeVersions);
  342.            
  343.             //check for special options if this is the SoapFormatter
  344.             IMethodMessage methodMsg = msg as IMethodMessage;
  345.             if (methodMsg != null) {
  346.                 MethodBase mb = methodMsg.MethodBase;
  347.                 if (mb != null) {
  348.                     Type type = methodMsg.MethodBase.DeclaringType;
  349.                     SoapTypeAttribute cache = (SoapTypeAttribute)InternalRemotingServices.GetCachedSoapAttribute(type);
  350.                     if ((cache.SoapOptions & SoapOption.AlwaysIncludeTypes) == SoapOption.AlwaysIncludeTypes)
  351.                         fmt.TypeFormat |= FormatterTypeStyle.TypesAlways;
  352.                     if ((cache.SoapOptions & SoapOption.XsdString) == SoapOption.XsdString)
  353.                         fmt.TypeFormat |= FormatterTypeStyle.XsdString;
  354.                 }
  355.             }
  356.             // end of set special options for SoapFormatter
  357.            
  358.             Header[] h = GetSoapHeaders(msg);
  359.            
  360.             // this is to make messages within a message serialize correctly
  361.             // and not use the fake type
  362.             ((RemotingSurrogateSelector)fmt.SurrogateSelector).SetRootObject(msg);
  363.             fmt.Serialize(outputStream, msg, h);
  364.         }
  365.         // SerializeSoapMessage
  366.         static internal Stream SerializeSoapMessage(IMessage msg, bool includeVersions)
  367.         {
  368.             MemoryStream memStream = new MemoryStream();
  369.             SerializeSoapMessage(msg, memStream, includeVersions);
  370.             memStream.Position = 0;
  371.             return memStream;
  372.         }
  373.         // SerializeSoapMessage
  374.        
  375.        
  376.         static internal void SerializeBinaryMessage(IMessage msg, Stream outputStream, bool includeVersions)
  377.         {
  378.             // create binary formatter
  379.             BinaryFormatter fmt = CreateBinaryFormatter(true, includeVersions);
  380.            
  381.             // WE SHOULD NOT CALL GetHeaders() here. The BinaryFormatter does special
  382.             // serialization for any headers that might be present.
  383.            
  384.             fmt.Serialize(outputStream, msg, null);
  385.         }
  386.         // SerializeBinaryMessage
  387.         static internal Stream SerializeBinaryMessage(IMessage msg, bool includeVersions)
  388.         {
  389.             MemoryStream memStream = new MemoryStream();
  390.             SerializeBinaryMessage(msg, memStream, includeVersions);
  391.             memStream.Position = 0;
  392.             return memStream;
  393.         }
  394.         // SerializeBinaryMessage
  395.        
  396.        
  397.         // class used to pass uri into binary serializer, so that the message
  398.         // gets the object uri.
  399.         private class UriHeaderHandler
  400.         {
  401.             string _uri = null;
  402.            
  403.             internal UriHeaderHandler(string uri)
  404.             {
  405.                 _uri = uri;
  406.             }
  407.            
  408.             public object HeaderHandler(Header[] Headers)
  409.             {
  410.                 return _uri;
  411.             }
  412.            
  413.         }
  414.         // classUriHeaderHandler
  415.        
  416.         static internal IMessage DeserializeSoapRequestMessage(Stream inputStream, Header[] h, bool bStrictBinding, TypeFilterLevel securityLevel)
  417.         {
  418.             SoapFormatter fmt = CreateSoapFormatter(false, bStrictBinding);
  419.             fmt.FilterLevel = securityLevel;
  420.            
  421.             MethodCall mc = new MethodCall(h);
  422.             fmt.Deserialize(inputStream, new HeaderHandler(mc.HeaderHandler));
  423.            
  424.             IMessage resMessage = (IMessage)mc;
  425.            
  426.             return resMessage;
  427.         }
  428.         // DeserializeSoapRequestMessage
  429.        
  430.         static internal IMessage DeserializeSoapResponseMessage(Stream inputStream, IMessage requestMsg, Header[] h, bool bStrictBinding)
  431.         {
  432.             SoapFormatter fmt = CreateSoapFormatter(false, bStrictBinding);
  433.            
  434.             IMethodCallMessage mcm = (IMethodCallMessage)requestMsg;
  435.             MethodResponse mr = new MethodResponse(h, mcm);
  436.             fmt.Deserialize(inputStream, new HeaderHandler(mr.HeaderHandler));
  437.            
  438.             IMessage resMessage = (IMessage)mr;
  439.            
  440.             return resMessage;
  441.         }
  442.         // DeserializeSoapResponseMessage
  443.        
  444.         static internal IMessage DeserializeBinaryRequestMessage(string objectUri, Stream inputStream, bool bStrictBinding, TypeFilterLevel securityLevel)
  445.         {
  446.             BinaryFormatter fmt = CreateBinaryFormatter(false, bStrictBinding);
  447.             fmt.FilterLevel = securityLevel;
  448.            
  449.             UriHeaderHandler uriHH = new UriHeaderHandler(objectUri);
  450.            
  451.             IMessage reqMsg = (IMessage)fmt.UnsafeDeserialize(inputStream, new HeaderHandler(uriHH.HeaderHandler));
  452.            
  453.             return reqMsg;
  454.         }
  455.         // DeserializeBinaryRequestMessage
  456.        
  457.         static internal IMessage DeserializeBinaryResponseMessage(Stream inputStream, IMethodCallMessage reqMsg, bool bStrictBinding)
  458.         {
  459.             BinaryFormatter fmt = CreateBinaryFormatter(false, bStrictBinding);
  460.            
  461.             IMessage replyMsg = (IMessage)fmt.UnsafeDeserializeMethodResponse(inputStream, null, reqMsg);
  462.             return replyMsg;
  463.         }
  464.         // DeserializeBinaryResponseMessage
  465.         static internal Stream SerializeMessage(string mimeType, IMessage msg, bool includeVersions)
  466.         {
  467.             Stream returnStream = new MemoryStream();
  468.             SerializeMessage(mimeType, msg, returnStream, includeVersions);
  469.             returnStream.Position = 0;
  470.             return returnStream;
  471.         }
  472.         // SerializeMessage
  473.        
  474.         static internal void SerializeMessage(string mimeType, IMessage msg, Stream outputStream, bool includeVersions)
  475.         {
  476.             InternalRemotingServices.RemotingTrace("SerializeMessage");
  477.             InternalRemotingServices.RemotingTrace("MimeType: " + mimeType);
  478.             CoreChannel.DebugMessage(msg);
  479.            
  480.             if (string.Compare(mimeType, SOAPMimeType, StringComparison.Ordinal) == 0) {
  481.                 SerializeSoapMessage(msg, outputStream, includeVersions);
  482.             }
  483.             else if (string.Compare(mimeType, BinaryMimeType, StringComparison.Ordinal) == 0) {
  484.                 SerializeBinaryMessage(msg, outputStream, includeVersions);
  485.             }
  486.            
  487.             InternalRemotingServices.RemotingTrace("SerializeMessage: OUT");
  488.         }
  489.         // SerializeMessage
  490.        
  491.        
  492.        
  493.         static internal IMessage DeserializeMessage(string mimeType, Stream xstm, bool methodRequest, IMessage msg)
  494.         {
  495.             return DeserializeMessage(mimeType, xstm, methodRequest, msg, null);
  496.         }
  497.        
  498.         static internal IMessage DeserializeMessage(string mimeType, Stream xstm, bool methodRequest, IMessage msg, Header[] h)
  499.         {
  500.             InternalRemotingServices.RemotingTrace("DeserializeMessage");
  501.             InternalRemotingServices.RemotingTrace("MimeType: " + mimeType);
  502.            
  503.             CoreChannel.DebugOutXMLStream(xstm, "Deserializing");
  504.            
  505.             Stream fmtStm = null;
  506.            
  507.             bool bin64encode = false;
  508.             bool doHeaderBodyAsOne = true;
  509.            
  510.             if (string.Compare(mimeType, BinaryMimeType, StringComparison.Ordinal) == 0) {
  511.                 doHeaderBodyAsOne = true;
  512.             }
  513.            
  514.             if (string.Compare(mimeType, SOAPMimeType, StringComparison.Ordinal) == 0) {
  515.                 doHeaderBodyAsOne = false;
  516.             }
  517.            
  518.             if (bin64encode == false) {
  519.                 fmtStm = xstm;
  520.             }
  521.             else {
  522.                 InternalRemotingServices.RemotingTrace("***************** Before base64 decode *****");
  523.                
  524.                 long Position = xstm.Position;
  525.                 MemoryStream inStm = (MemoryStream)xstm;
  526.                 byte[] byteArray = inStm.ToArray();
  527.                 xstm.Position = Position;
  528.                
  529.                 string base64String = Encoding.ASCII.GetString(byteArray, 0, byteArray.Length);
  530.                
  531.                 byte[] byteArrayContent = Convert.FromBase64String(base64String);
  532.                
  533.                 MemoryStream memStm = new MemoryStream(byteArrayContent);
  534.                
  535.                 fmtStm = memStm;
  536.                 InternalRemotingServices.RemotingTrace("***************** after base64 decode *****");
  537.             }
  538.            
  539.             object ret;
  540.             IRemotingFormatter fmt = MimeTypeToFormatter(mimeType, false);
  541.            
  542.             if (doHeaderBodyAsOne == true) {
  543.                 ret = ((BinaryFormatter)fmt).UnsafeDeserializeMethodResponse(fmtStm, null, (IMethodCallMessage)msg);
  544.             }
  545.             else {
  546.                 InternalRemotingServices.RemotingTrace("Content");
  547.                 InternalRemotingServices.RemotingTrace("***************** Before Deserialize Headers *****");
  548.                
  549.                 InternalRemotingServices.RemotingTrace("***************** After Deserialize Headers *****");
  550.                
  551.                 InternalRemotingServices.RemotingTrace("***************** Before Deserialize Message *****");
  552.                
  553.                 if (methodRequest == true) {
  554.                     MethodCall mc = new MethodCall(h);
  555.                     InternalRemotingServices.RemotingTrace("***************** Before Deserialize Message - as MethodCall *****");
  556.                     fmt.Deserialize(fmtStm, new HeaderHandler(mc.HeaderHandler));
  557.                     ret = mc;
  558.                 }
  559.                 else {
  560.                     IMethodCallMessage mcm = (IMethodCallMessage)msg;
  561.                     MethodResponse mr = new MethodResponse(h, mcm);
  562.                     InternalRemotingServices.RemotingTrace("***************** Before Deserialize Message - as MethodResponse *****");
  563.                     fmt.Deserialize(fmtStm, new HeaderHandler(mr.HeaderHandler));
  564.                     ret = mr;
  565.                 }
  566.                
  567.                 InternalRemotingServices.RemotingTrace("***************** After Deserialize Message *****");
  568.             }
  569.            
  570.             // Workaround to make this method verifiable
  571.             IMessage resMessage = (IMessage)ret;
  572.            
  573.             InternalRemotingServices.RemotingTrace("CoreChannel::DeserializeMessage OUT");
  574.             CoreChannel.DebugMessage(resMessage);
  575.            
  576.             return resMessage;
  577.         }
  578.        
  579.        
  580.        
  581.         static internal IRemotingFormatter MimeTypeToFormatter(string mimeType, bool serialize)
  582.         {
  583.             InternalRemotingServices.RemotingTrace("MimeTypeToFormatter: mimeType: " + mimeType);
  584.            
  585.             if (string.Compare(mimeType, SOAPMimeType, StringComparison.Ordinal) == 0) {
  586.                 return CreateSoapFormatter(serialize, true);
  587.             }
  588.             else if (string.Compare(mimeType, BinaryMimeType, StringComparison.Ordinal) == 0) {
  589.                 return CreateBinaryFormatter(serialize, true);
  590.             }
  591.            
  592.             return null;
  593.         }
  594.         // MimeTypeToFormatter
  595.        
  596.         //
  597.         // Other helper methods
  598.         //
  599.        
  600.         // Removes application name from front of uri if present.
  601.         static internal string RemoveApplicationNameFromUri(string uri)
  602.         {
  603.             if (uri == null)
  604.                 return null;
  605.            
  606.             string appName = RemotingConfiguration.ApplicationName;
  607.             if ((appName == null) || (appName.Length == 0))
  608.                 return uri;
  609.            
  610.             // uri must be longer than the appname plus a slash (hence the "+2")
  611.             if (uri.Length < (appName.Length + 2))
  612.                 return uri;
  613.            
  614.             // case-insensitively determine if uri starts with app name
  615.             if (String.Compare(appName, 0, uri, 0, appName.Length, StringComparison.OrdinalIgnoreCase) == 0) {
  616.                 // make sure a slash follows the app name (we already made sure
  617.                 // uri was long enough above)
  618.                 if (uri[appName.Length] == '/') {
  619.                     uri = uri.Substring(appName.Length + 1);
  620.                 }
  621.             }
  622.            
  623.             return uri;
  624.         }
  625.         // RemoveApplicationNameFromUri
  626.        
  627.         static internal void AppendProviderToClientProviderChain(IClientChannelSinkProvider providerChain, IClientChannelSinkProvider provider)
  628.         {
  629.             if (providerChain == null)
  630.                 throw new ArgumentNullException("providerChain");
  631.            
  632.             // walk to last provider in chain
  633.             while (providerChain.Next != null) {
  634.                 providerChain = providerChain.Next;
  635.             }
  636.            
  637.             providerChain.Next = provider;
  638.         }
  639.         // AppendProviderToClientProviderChain
  640.         static internal void CollectChannelDataFromServerSinkProviders(ChannelDataStore channelData, IServerChannelSinkProvider provider)
  641.         {
  642.             // walk chain and ask each provider for channel data
  643.             while (provider != null) {
  644.                 provider.GetChannelData(channelData);
  645.                
  646.                 provider = provider.Next;
  647.             }
  648.         }
  649.         // CollectChannelDataFromServerSinkProviders
  650.        
  651.         // called by providers that aren't expecting custom provider data
  652.         static internal void VerifyNoProviderData(string providerTypeName, ICollection providerData)
  653.         {
  654.             if ((providerData != null) && (providerData.Count > 0)) {
  655.                 throw new RemotingException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Providers_Config_NotExpectingProviderData"), providerTypeName));
  656.             }
  657.         }
  658.         // VerifyNoProviderData
  659.         static internal void ReportUnknownProviderConfigProperty(string providerTypeName, string propertyName)
  660.         {
  661.             throw new RemotingException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Providers_Config_UnknownProperty"), providerTypeName, propertyName));
  662.         }
  663.         // ReportUnknownProviderConfigProperty
  664.        
  665.        
  666.         static internal SinkChannelProtocol DetermineChannelProtocol(IChannel channel)
  667.         {
  668.             string objectUri;
  669.             string channelUri = channel.Parse("http://foo.com/foo", out objectUri);
  670.             if (channelUri != null)
  671.                 return SinkChannelProtocol.Http;
  672.            
  673.             return SinkChannelProtocol.Other;
  674.         }
  675.         // DetermineChannelProtocol
  676.        
  677.         static internal bool SetupUrlBashingForIisSslIfNecessary()
  678.         {
  679.             // Rotor doesn't support SSL.
  680.             return false;
  681.         }
  682.         // SetupUrlBashingForIisSslIfNecessary
  683.         static internal void CleanupUrlBashingForIisSslIfNecessary(bool bBashedUrl)
  684.         {
  685.             return;
  686.         }
  687.         // CleanupUrlBashingForIisSslIfNecessary
  688.        
  689.        
  690.         //** Resource helpers ***************************************************
  691.         static internal ResourceManager SystemResMgr;
  692.        
  693.         private static ResourceManager InitResourceManager()
  694.         {
  695.             if (SystemResMgr == null)
  696.                 SystemResMgr = new ResourceManager("System.Runtime.Remoting", typeof(CoreChannel).Module.Assembly);
  697.             return SystemResMgr;
  698.         }
  699.        
  700.         // Looks up the resource string value for key.
  701.         //
  702.         static internal string GetResourceString(string key)
  703.         {
  704.             if (SystemResMgr == null)
  705.                 InitResourceManager();
  706.             string s = SystemResMgr.GetString(key, null);
  707.             Debug.Assert(s != null, "Resource string lookup failed. Resource name was: \"" + key + "\"");
  708.             return s;
  709.         }
  710.        
  711.         //** Debug items ***************************************************
  712.         [Conditional("_DEBUG")]
  713.         static internal void DebugOut(string s)
  714.         {
  715.             InternalRemotingServices.DebugOutChnl(s);
  716.         }
  717.        
  718.         [Conditional("_DEBUG")]
  719.         static internal void DebugOutXMLStream(Stream stm, string tag)
  720.         {
  721.             /*
  722.             This can't be done when using networked streams.
  723.             long oldpos = stm.Position;
  724.             stm.Position=0;
  725.             StreamReader sr = new StreamReader(stm, Encoding.UTF8);
  726.             String line;
  727.             InternalRemotingServices.DebugOutChnl("\n  -----------" + tag + " OPEN-------------\n") ;
  728.             while ((line = sr.ReadLine()) != null)
  729.             {
  730.                 InternalRemotingServices.DebugOutChnl(line);
  731.             }
  732.             InternalRemotingServices.DebugOutChnl("\n  -----------" + tag + " CLOSE------------\n") ;
  733.             stm.Position = oldpos;
  734.             */           
  735.         }
  736.        
  737.         [Conditional("_DEBUG")]
  738.         static internal void DebugMessage(IMessage msg)
  739.         {
  740.             /*
  741.               if (msg is IMethodCallMessage)
  742.                 InternalRemotingServices.RemotingTrace("IMethodCallMessage");
  743.                
  744.               if (msg is IMethodReturnMessage)
  745.                 InternalRemotingServices.RemotingTrace("IMethodReturnMessage");
  746.        
  747.               if (msg == null)
  748.                 InternalRemotingServices.RemotingTrace("***** IMessage is null");
  749.        
  750.               InternalRemotingServices.RemotingTrace("DebugMessage Here");
  751.               IDictionary d = msg.Properties;
  752.               if (d == null)
  753.                 InternalRemotingServices.RemotingTrace("***** Properties is null");
  754.        
  755.               InternalRemotingServices.RemotingTrace("DebugMessage Here0");     
  756.               if (d.Count == 0)
  757.               {
  758.                   InternalRemotingServices.RemotingTrace("Zero Properties");
  759.                   return;
  760.               }
  761.        
  762.               InternalRemotingServices.RemotingTrace("DebugMessage Here1");
  763.               IDictionaryEnumerator e = (IDictionaryEnumerator) d.GetEnumerator();
  764.               InternalRemotingServices.RemotingTrace("DebugMessage Here1");
  765.        
  766.               while (e.MoveNext())
  767.               {
  768.                 InternalRemotingServices.RemotingTrace("DebugMessage Here2");
  769.        
  770.                 Object key = e.Key;
  771.                
  772.                 InternalRemotingServices.RemotingTrace("DebugMessage Here3");
  773.        
  774.                 String keyName = key.ToString();
  775.        
  776.                 InternalRemotingServices.RemotingTrace("DebugMessage Here4");
  777.        
  778.                 Object value = e.Value;
  779.        
  780.                 InternalRemotingServices.RemotingTrace("DebugMessage Here5");
  781.        
  782.                 InternalRemotingServices.RemotingTrace(keyName + ":" + e.Value);
  783.        
  784.                 InternalRemotingServices.RemotingTrace("DebugMessage Here6");
  785.        
  786.                 if (String.Compare(keyName, "__CallContext", StringComparison.OrdinalIgnoreCase) == 0)
  787.                 {
  788.                 }
  789.                
  790.                 InternalRemotingServices.RemotingTrace("DebugMessage Here7");
  791.               }
  792.               */           
  793.         }
  794.        
  795.         [Conditional("_DEBUG")]
  796.         static internal void DebugException(string name, Exception e)
  797.         {
  798.             InternalRemotingServices.RemotingTrace("****************************************************\r\n");
  799.             InternalRemotingServices.RemotingTrace("EXCEPTION THROWN!!!!!! - " + name);
  800.             InternalRemotingServices.RemotingTrace("\r\n");
  801.            
  802.             InternalRemotingServices.RemotingTrace(e.Message);
  803.             InternalRemotingServices.RemotingTrace("\r\n");
  804.            
  805.             InternalRemotingServices.RemotingTrace(e.GetType().FullName);
  806.             InternalRemotingServices.RemotingTrace("\r\n");
  807.            
  808.             InternalRemotingServices.RemotingTrace(e.StackTrace);
  809.             InternalRemotingServices.RemotingTrace("\r\n");
  810.             InternalRemotingServices.RemotingTrace("****************************************************\r\n");
  811.         }
  812.        
  813.         [Conditional("_DEBUG")]
  814.         static internal void DebugStream(Stream stm)
  815.         {
  816.             /*
  817.               try
  818.               {
  819.                 long Position = stm.Position;
  820.        
  821.                 MemoryStream memStm = (MemoryStream)stm;
  822.                 byte[] byteArray = memStm.ToArray();
  823.                 int byteArrayLength = byteArray.Length;
  824.                 String streamString = Encoding.ASCII.GetString(byteArray,0, byteArrayLength);
  825.                 InternalRemotingServices.RemotingTrace(streamString);
  826.                 stm.Position = Position;
  827.               }
  828.               catch(Exception e)
  829.               {
  830.                 DebugException("DebugStream", e);
  831.               }
  832.               */           
  833.         }
  834.        
  835.     }
  836.     // class CoreChannel
  837.    
  838.    
  839. }

Developer Fusion