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.Net \ Blob

SSCLI
  1. //------------------------------------------------------------------------------
  2. // <copyright file="Internal.cs" company="Microsoft">
  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. // </copyright>
  14. //------------------------------------------------------------------------------
  16. namespace System.Net
  17. {
  18.     using System.IO;
  19.     using System.Reflection;
  20.     using System.Collections;
  21.     using System.Collections.Generic;
  22.     using System.Collections.Specialized;
  23.     using System.Globalization;
  24.     using System.Net.Sockets;
  25.     using System.Runtime.InteropServices;
  26.     using System.Runtime.Versioning;
  27.     using System.Security.Cryptography.X509Certificates;
  28.     using System.Text;
  29.     using System.Text.RegularExpressions;
  30.     using System.Security.Permissions;
  31.     using System.Diagnostics;
  32.     using System.Threading;
  33.     using System.Security.Principal;
  34.     using System.Security;
  35.     using System.Net.Security;
  36.     using System.Net.NetworkInformation;
  37.     using System.Runtime.Serialization;
  38.    
  39.     static internal class IntPtrHelper
  40.     {
  41. /*
  42.         //                                   
  43.         internal static IntPtr Add(IntPtr a, IntPtr b) {
  44.             return (IntPtr) ((long)a + (long)b);
  45.         }
  46.         */       
  47.         static internal IntPtr Add(IntPtr a, int b)
  48.         {
  49.             return (IntPtr)((long)a + (long)b);
  50.         }
  51.     }
  52.    
  53.     internal class InternalException : SystemException
  54.     {
  55.         internal InternalException()
  56.         {
  57.             GlobalLog.Assert("InternalException thrown.");
  58.         }
  59.        
  60.         internal InternalException(SerializationInfo serializationInfo, StreamingContext streamingContext) : base(serializationInfo, streamingContext)
  61.         {
  62.         }
  63.     }
  64.    
  65.     static internal class NclUtilities
  66.     {
  67.         /// <devdoc>
  68.         /// <para>
  69.         /// Indicates true if the threadpool is low on threads,
  70.         /// in this case we need to refuse to start new requests,
  71.         /// and avoid blocking.
  72.         /// </para>
  73.         /// </devdoc>
  74.         static internal bool IsThreadPoolLow()
  75.         {
  76.            
  77.             int workerThreads;
  78.             int completionPortThreads;
  79.             ThreadPool.GetAvailableThreads(out workerThreads, out completionPortThreads);
  80.            
  81.             return workerThreads < 2 || completionPortThreads < 2;
  82.         }
  83.        
  84.         static internal bool HasShutdownStarted {
  85.             get { return Environment.HasShutdownStarted || AppDomain.CurrentDomain.IsFinalizingForUnload(); }
  86.         }
  87.        
  88.        
  89.         // ContextRelativeDemand
  90.         // Allows easily demanding a permission against a given ExecutionContext.
  91.         // Have requested the CLR to provide this method on ExecutionContext.
  92.         private static ContextCallback s_ContextRelativeDemandCallback;
  93.        
  94.         static internal ContextCallback ContextRelativeDemandCallback {
  95.             get {
  96.                 if (s_ContextRelativeDemandCallback == null)
  97.                     s_ContextRelativeDemandCallback = new ContextCallback(DemandCallback);
  98.                 return s_ContextRelativeDemandCallback;
  99.             }
  100.         }
  101.        
  102.         private static void DemandCallback(object state)
  103.         {
  104.             ((CodeAccessPermission)state).Demand();
  105.         }
  106.        
  107.         // This is for checking if a hostname probably refers to this machine without going to DNS.
  108.         static internal bool GuessWhetherHostIsLoopback(string host)
  109.         {
  110.             string hostLower = host.ToLowerInvariant();
  111.             if (hostLower == "localhost" || hostLower == "loopback") {
  112.                 return true;
  113.             }
  114.            
  115.             return false;
  116.         }
  117.        
  118.         static internal bool IsFatal(Exception exception)
  119.         {
  120.             return exception != null && (exception is OutOfMemoryException || exception is StackOverflowException || exception is ThreadAbortException);
  121.         }
  122.        
  123.         // Need a fast cached list of local addresses for internal use.
  124.         private static IPAddress[] _LocalAddresses;
  125.         private static object _LocalAddressesLock;
  126.        
  127.         private const int HostNameBufferLength = 256;
  128.         static internal string _LocalDomainName;
  129.        
  130.         // Copied from the old version of DNS.cs
  131.         // Returns a list of our local addresses by calling gethostbyname with null.
  132.         //
  133.         private static IPHostEntry GetLocalHost()
  134.         {
  135.             //
  136.             // IPv6 Changes: If IPv6 is enabled, we can't simply use the
  137.             // old IPv4 gethostbyname(null). Instead we need
  138.             // to do a more complete lookup.
  139.             //
  140.             if (Socket.SupportsIPv6) {
  141.                 //
  142.                 // IPv6 enabled: use getaddrinfo() of the local host name
  143.                 // to obtain this information. Need to get the machines
  144.                 // name as well - do that here so that we don't need to
  145.                 // Assert DNS permissions.
  146.                 //
  147.                 StringBuilder hostname = new StringBuilder(HostNameBufferLength);
  148.                 SocketError errorCode = UnsafeNclNativeMethods.OSSOCK.gethostname(hostname, HostNameBufferLength);
  149.                
  150.                 if (errorCode != SocketError.Success) {
  151.                     throw new SocketException();
  152.                 }
  153.                
  154.                 return Dns.GetHostByName(hostname.ToString());
  155.             }
  156.             else {
  157.                 //
  158.                 // IPv6 disabled: use gethostbyname() to obtain information.
  159.                 //
  160.                 IntPtr nativePointer = UnsafeNclNativeMethods.OSSOCK.gethostbyname(null);
  161.                
  162.                 if (nativePointer == IntPtr.Zero) {
  163.                     throw new SocketException();
  164.                 }
  165.                
  166.                 return Dns.NativeToHostEntry(nativePointer);
  167.             }
  168.            
  169.         }
  170.         // GetLocalHost
  171.         static internal IPAddress[] LocalAddresses {
  172.             get {
  173.                 IPAddress[] local = _LocalAddresses;
  174.                 if (local != null) {
  175.                     return local;
  176.                 }
  177.                
  178.                 lock (LocalAddressesLock) {
  179.                     local = _LocalAddresses;
  180.                     if (local != null) {
  181.                         return local;
  182.                     }
  183.                    
  184.                     List<IPAddress> localList = new List<IPAddress>();
  185.                    
  186.                     try {
  187.                         IPHostEntry hostEntry = GetLocalHost();
  188.                         if (hostEntry != null) {
  189.                             if (hostEntry.HostName != null) {
  190.                                 int dot = hostEntry.HostName.IndexOf('.');
  191.                                 if (dot != -1) {
  192.                                     _LocalDomainName = hostEntry.HostName.Substring(dot);
  193.                                 }
  194.                             }
  195.                            
  196.                             IPAddress[] ipAddresses = hostEntry.AddressList;
  197.                             if (ipAddresses != null) {
  198.                                 foreach (IPAddress ipAddress in ipAddresses) {
  199.                                     localList.Add(ipAddress);
  200.                                 }
  201.                             }
  202.                         }
  203.                     }
  204.                     catch {
  205.                     }
  206.                    
  207.                     local = new IPAddress[localList.Count];
  208.                     int index = 0;
  209.                     foreach (IPAddress ipAddress in localList) {
  210.                         local[index] = ipAddress;
  211.                         index++;
  212.                     }
  213.                     _LocalAddresses = local;
  214.                    
  215.                     return local;
  216.                 }
  217.             }
  218.         }
  219.        
  220.         static internal bool IsAddressLocal(IPAddress ipAddress)
  221.         {
  222.             IPAddress[] localAddresses = NclUtilities.LocalAddresses;
  223.             for (int i = 0; i < localAddresses.Length; i++) {
  224.                 if (ipAddress.Equals(localAddresses[i], false)) {
  225.                     return true;
  226.                 }
  227.             }
  228.             return false;
  229.         }
  230.        
  231.         private static object LocalAddressesLock {
  232.             get {
  233.                 if (_LocalAddressesLock == null) {
  234.                     Interlocked.CompareExchange(ref _LocalAddressesLock, new object(), null);
  235.                 }
  236.                 return _LocalAddressesLock;
  237.             }
  238.         }
  239.     }
  240.    
  241.     static internal class NclConstants
  242.     {
  243.         static internal readonly object Sentinel = new object();
  244.         static internal readonly object[] EmptyObjectArray = new object[0];
  245.         static internal readonly Uri[] EmptyUriArray = new Uri[0];
  246.        
  247.         static internal readonly byte[] CRLF = new byte[] {(byte)'\r', (byte)'\n'};
  248.         static internal readonly byte[] ChunkTerminator = new byte[] {(byte)'0', (byte)'\r', (byte)'\n', (byte)'\r', (byte)'\n'};
  249.     }
  250.    
  251.     //
  252.     // A simple sync point, useful for deferring work. Just an int value with helper methods.
  253.     //
  254.     // The two events being synchronized are the "Triggering" event and the "Completing" event. The Triggering event
  255.     // marks the gate as being active; the first subsequent Completing event handles the action.
  256.     //
  257.     // First, a thread calls Trigger() to set the trigger on the gate. This means it needs some work to be done, but only
  258.     // after another operation (the Completing event) finishes. If Trigger() returns false, the Completing event already
  259.     // happened. When the Completing event occurs, that thread calls Complete(). It returns true if the gate has been
  260.     // previously triggered and the caller is the first one to complete it. The caller should then handle the pending work item.
  261.     //
  262.     // StartTrigger()/FinishTrigger() can be used instead of Trigger() if the triggering thread needs to set up some state
  263.     // (e.g. the pending work item). It will block Complete() in a spin-lock.
  264.     //
  265.     internal struct InterlockedGate
  266.     {
  267.         private int m_State;
  268.        
  269.         internal const int Open = 0;
  270.         // Initial state of gate.
  271.         internal const int Held = 1;
  272.         // Gate is being actively held by a thread - indeterminate state.
  273.         internal const int Triggered = 2;
  274.         // The triggering event has occurred.
  275.         internal const int Closed = 3;
  276.         // The gated event is done.
  277.         #if DEBUG
  278. /* Consider removing
  279.         internal int State
  280.         {
  281.             get
  282.             {
  283.                 return m_State;
  284.             }
  285.         }
  286.         */       
  287.         #endif
  288.        
  289.         // Only call when all threads are guaranteed to be done with the gate.
  290.         internal void Reset()
  291.         {
  292.             m_State = Open;
  293.         }
  294.        
  295.         // Returns false if the gate is already closed or triggered. If exclusive is true, throws if the gate is already
  296.         // triggered.
  297.         internal bool Trigger(bool exclusive)
  298.         {
  299.             int gate = Interlocked.CompareExchange(ref m_State, Triggered, Open);
  300.             if (exclusive && (gate == Held || gate == Triggered)) {
  301.                 GlobalLog.Assert("InterlockedGate::Trigger", "Gate already triggered.");
  302.                 throw new InternalException();
  303.             }
  304.             return gate == Open;
  305.         }
  306.        
  307.         // Use StartTrigger() and FinishTrigger() to trigger the gate as a two step operation. This is useful to set up an invariant
  308.         // that must be ready by the time another thread closes the gate. Do not block between StartTrigger() and FinishTrigger(), just
  309.         // set up your state to be consistent. If this method returns true, FinishTrigger() *must* be called to avoid deadlock - do
  310.         // it in a finally.
  311.         //
  312.         // Returns false if the gate is already closed or triggered. If exclusive is true, throws if the gate is already
  313.         // triggered.
  314.         internal bool StartTrigger(bool exclusive)
  315.         {
  316.             int gate = Interlocked.CompareExchange(ref m_State, Held, Open);
  317.             if (exclusive && (gate == Held || gate == Triggered)) {
  318.                 GlobalLog.Assert("InterlockedGate::StartTrigger", "Gate already triggered.");
  319.                 throw new InternalException();
  320.             }
  321.             return gate == Open;
  322.         }
  323.        
  324.         // Gate must be held by StartTrigger().
  325.         internal void FinishTrigger()
  326.         {
  327.             int gate = Interlocked.CompareExchange(ref m_State, Triggered, Held);
  328.             if (gate != Held) {
  329.                 GlobalLog.Assert("InterlockedGate::FinishTrigger", "Gate not held.");
  330.                 throw new InternalException();
  331.             }
  332.         }
  333.        
  334.         // Returns false if the gate had never been triggered or is already closed.
  335.         internal bool Complete()
  336.         {
  337.             int gate;
  338.            
  339.             // Spin while the gate is being held, allowing the other thread to set invariants up.
  340.             while ((gate = Interlocked.CompareExchange(ref m_State, Closed, Triggered)) != Triggered) {
  341.                 if (gate == Closed) {
  342.                     return false;
  343.                 }
  344.                
  345.                 if (gate == Open) {
  346.                     if (Interlocked.CompareExchange(ref m_State, Closed, Open) == Open) {
  347.                         return false;
  348.                     }
  349.                    
  350.                     continue;
  351.                 }
  352.                
  353.                 // gate == Held
  354.                 Thread.SpinWait(1);
  355.             }
  356.            
  357.             return true;
  358.         }
  359.     }
  360.    
  361.    
  362.    
  363.    
  364.    
  365.    
  366.     //
  367.     // support class for Validation related stuff.
  368.     //
  369.     static internal class ValidationHelper
  370.     {
  371.        
  372.         public static string[] EmptyArray = new string[0];
  373.        
  374.         static internal readonly char[] InvalidMethodChars = new char[] {' ', '\r', '\n', '\t'};
  375.        
  376.         // invalid characters that cannot be found in a valid method-verb or http header
  377.         static internal readonly char[] InvalidParamChars = new char[] {'(', ')', '<', '>', '@', ',', ';', ':', '\\', '"',
  378.         '\'', '/', '[', ']', '?', '=', '{', '}', ' ', '\t',
  379.         '\r', '\n'};
  380.        
  381.         public static string[] MakeEmptyArrayNull(string[] stringArray)
  382.         {
  383.             if (stringArray == null || stringArray.Length == 0) {
  384.                 return null;
  385.             }
  386.             else {
  387.                 return stringArray;
  388.             }
  389.         }
  390.        
  391.         public static string MakeStringNull(string stringValue)
  392.         {
  393.             if (stringValue == null || stringValue.Length == 0) {
  394.                 return null;
  395.             }
  396.             else {
  397.                 return stringValue;
  398.             }
  399.         }
  400.        
  401. /*
  402.         //                                   
  403.         public static string MakeStringEmpty(string stringValue) {
  404.             if ( stringValue == null || stringValue.Length == 0) {
  405.                 return String.Empty;
  406.             } else {
  407.                 return stringValue;
  408.             }
  409.         }
  410.         */       
  411.        
  412.        
  413.         public static string ExceptionMessage(Exception exception)
  414.         {
  415.             if (exception == null) {
  416.                 return string.Empty;
  417.             }
  418.             if (exception.InnerException == null) {
  419.                 return exception.Message;
  420.             }
  421.             return exception.Message + " (" + ExceptionMessage(exception.InnerException) + ")";
  422.         }
  423.        
  424.         public static string ToString(object objectValue)
  425.         {
  426.             if (objectValue == null) {
  427.                 return "(null)";
  428.             }
  429.             else if (objectValue is string && ((string)objectValue).Length == 0) {
  430.                 return "(string.empty)";
  431.             }
  432.             else if (objectValue is Exception) {
  433.                 return ExceptionMessage(objectValue as Exception);
  434.             }
  435.             else if (objectValue is IntPtr) {
  436.                 return "0x" + ((IntPtr)objectValue).ToString("x");
  437.             }
  438.             else {
  439.                 return objectValue.ToString();
  440.             }
  441.         }
  442.         public static string HashString(object objectValue)
  443.         {
  444.             if (objectValue == null) {
  445.                 return "(null)";
  446.             }
  447.             else if (objectValue is string && ((string)objectValue).Length == 0) {
  448.                 return "(string.empty)";
  449.             }
  450.             else {
  451.                 return objectValue.GetHashCode().ToString(NumberFormatInfo.InvariantInfo);
  452.             }
  453.         }
  454.        
  455.         public static bool IsInvalidHttpString(string stringValue)
  456.         {
  457.             return stringValue.IndexOfAny(InvalidParamChars) != -1;
  458.         }
  459.        
  460.         public static bool IsBlankString(string stringValue)
  461.         {
  462.             return stringValue == null || stringValue.Length == 0;
  463.         }
  464.        
  465. /*
  466.         //                                   
  467.         public static bool ValidateUInt32(long address) {
  468.             // on false, API should throw new ArgumentOutOfRangeException("address");
  469.             return address>=0x00000000 && address<=0xFFFFFFFF;
  470.         }
  471.         */       
  472.        
  473.         public static bool ValidateTcpPort(int port)
  474.         {
  475.             // on false, API should throw new ArgumentOutOfRangeException("port");
  476.             return port >= IPEndPoint.MinPort && port <= IPEndPoint.MaxPort;
  477.         }
  478.        
  479.         public static bool ValidateRange(int actual, int fromAllowed, int toAllowed)
  480.         {
  481.             // on false, API should throw new ArgumentOutOfRangeException("argument");
  482.             return actual >= fromAllowed && actual <= toAllowed;
  483.         }
  484.        
  485.         /*
  486.         //                                   
  487.         public static bool ValidateRange(long actual, long fromAllowed, long toAllowed) {
  488.             // on false, API should throw new ArgumentOutOfRangeException("argument");
  489.             return actual>=fromAllowed && actual<=toAllowed;
  490.         }
  491.         */       
  492.     }
  493.    
  494.     static internal class ExceptionHelper
  495.     {
  496.         static internal readonly WebPermission WebPermissionUnrestricted = new WebPermission(NetworkAccess.Connect);
  497.         static internal readonly SecurityPermission UnmanagedPermission = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode);
  498.         static internal readonly SocketPermission UnrestrictedSocketPermission = new SocketPermission(PermissionState.Unrestricted);
  499.         static internal readonly SecurityPermission InfrastructurePermission = new SecurityPermission(SecurityPermissionFlag.Infrastructure);
  500.         static internal readonly SecurityPermission ControlPolicyPermission = new SecurityPermission(SecurityPermissionFlag.ControlPolicy);
  501.         static internal readonly SecurityPermission ControlPrincipalPermission = new SecurityPermission(SecurityPermissionFlag.ControlPrincipal);
  502.        
  503.         static internal NotImplementedException MethodNotImplementedException {
  504.             get { return new NotImplementedException(SR.GetString(SR.net_MethodNotImplementedException)); }
  505.         }
  506.        
  507.         static internal NotImplementedException PropertyNotImplementedException {
  508.             get { return new NotImplementedException(SR.GetString(SR.net_PropertyNotImplementedException)); }
  509.         }
  510.        
  511.         static internal NotSupportedException MethodNotSupportedException {
  512.             get { return new NotSup