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

SSCLI
  1. //------------------------------------------------------------------------------
  2. // <copyright fieldInfole="_AutoWebProxyScriptEngine.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.Collections;
  20.     using System.Collections.Specialized;
  21.     using System.Threading;
  22.     using System.Text;
  23.     using System.Net.Cache;
  24.     using System.Globalization;
  25.     using System.Net.Configuration;
  26.     using System.Security.Permissions;
  27.    
  28.     enum AutoWebProxyState
  29.     {
  30.         Uninitialized = 0,
  31.         DiscoveryFailure = 1,
  32.         DiscoverySuccess = 2,
  33.         DownloadFailure = 3,
  34.         DownloadSuccess = 4,
  35.         CompilationFailure = 5,
  36.         CompilationSuccess = 6,
  37.         ExecutionFailure = 7,
  38.         ExecutionSuccess = 8
  39.     }
  40.    
  41.     /// <summary>
  42.     /// Simple EXE host for the AutoWebProxyScriptEngine. Pushes the contents of a script file
  43.     /// into the engine and executes it. Exposes the JScript model used in IE 3.2 - 6,
  44.     /// for resolving which proxy to use.
  45.     /// </summary>
  46.     internal class AutoWebProxyScriptEngine
  47.     {
  48.         private static readonly char[] splitChars = new char[] {';'};
  49.        
  50.         private static TimerThread.Queue s_TimerQueue;
  51.         private static readonly TimerThread.Callback s_TimerCallback = new TimerThread.Callback(RequestTimeoutCallback);
  52.         private static readonly WaitCallback s_AbortWrapper = new WaitCallback(AbortWrapper);
  53.        
  54.         private bool automaticallyDetectSettings;
  55.         private Uri automaticConfigurationScript;
  56.        
  57.         private AutoWebProxyScriptWrapper scriptInstance;
  58.         internal AutoWebProxyState state;
  59.         private Uri engineScriptLocation;
  60.         private WebProxy webProxy;
  61.        
  62.         private RequestCache backupCache;
  63.        
  64.         // Used by abortable lock.
  65.         private bool m_LockHeld;
  66.         private WebRequest m_LockedRequest;
  67.        
  68.         private bool m_UseRegistry;
  69.        
  70.        
  71.         [SecurityPermission(SecurityAction.Assert, Flags = SecurityPermissionFlag.ControlPrincipal)]
  72.         internal AutoWebProxyScriptEngine(WebProxy proxy, bool useRegistry)
  73.         {
  74.             webProxy = proxy;
  75.             m_UseRegistry = useRegistry;
  76.            
  77.             backupCache = new SingleItemRequestCache(RequestCacheManager.IsCachingEnabled);
  78.         }
  79.        
  80.        
  81.         // AutoWebProxyScriptEngine has special abortable locking. No one should ever lock (this) except the locking helper methods below.
  82.         private static class SyncStatus
  83.         {
  84.             internal const int Unlocked = 0;
  85.             internal const int Locking = 1;
  86.             internal const int LockOwner = 2;
  87.             internal const int RequestOwner = 3;
  88.             internal const int AbortedLocked = 4;
  89.             internal const int Aborted = 5;
  90.         }
  91.        
  92.         private void EnterLock(ref int syncStatus)
  93.         {
  94.             if (syncStatus == SyncStatus.Unlocked) {
  95.                 lock (this) {
  96.                     if (syncStatus != SyncStatus.Aborted) {
  97.                         syncStatus = SyncStatus.Locking;
  98.                         while (true) {
  99.                             if (!m_LockHeld) {
  100.                                 syncStatus = SyncStatus.LockOwner;
  101.                                 m_LockHeld = true;
  102.                                 return;
  103.                             }
  104.                             Monitor.Wait(this);
  105.                             if (syncStatus == SyncStatus.Aborted) {
  106.                                 Monitor.Pulse(this);
  107.                                 // This is to ensure that a Pulse meant to let someone take the lock isn't lost.
  108.                                 return;
  109.                             }
  110.                         }
  111.                     }
  112.                 }
  113.             }
  114.         }
  115.        
  116.         private void ExitLock(ref int syncStatus)
  117.         {
  118.             if (syncStatus != SyncStatus.Unlocked && syncStatus != SyncStatus.Aborted) {
  119.                 lock (this) {
  120.                     if (syncStatus == SyncStatus.RequestOwner) {
  121.                         m_LockedRequest = null;
  122.                     }
  123.                     m_LockHeld = false;
  124.                     if (syncStatus == SyncStatus.AbortedLocked) {
  125.                         state = AutoWebProxyState.Uninitialized;
  126.                         syncStatus = SyncStatus.Aborted;
  127.                     }
  128.                     else {
  129.                         syncStatus = SyncStatus.Unlocked;
  130.                     }
  131.                     Monitor.Pulse(this);
  132.                 }
  133.             }
  134.         }
  135.        
  136.         private void LockRequest(WebRequest request, ref int syncStatus)
  137.         {
  138.             lock (this) {
  139.                 switch (syncStatus) {
  140.                     case SyncStatus.LockOwner:
  141.                         m_LockedRequest = request;
  142.                         syncStatus = SyncStatus.RequestOwner;
  143.                         break;
  144.                     case SyncStatus.RequestOwner:
  145.                        
  146.                         m_LockedRequest = request;
  147.                         break;
  148.                 }
  149.             }
  150.         }
  151.        
  152.         internal void Abort(ref int syncStatus)
  153.         {
  154.             lock (this) {
  155.                 switch (syncStatus) {
  156.                     case SyncStatus.Unlocked:
  157.                         syncStatus = SyncStatus.Aborted;
  158.                         break;
  159.                     case SyncStatus.Locking:
  160.                        
  161.                         syncStatus = SyncStatus.Aborted;
  162.                         Monitor.PulseAll(this);
  163.                         break;
  164.                     case SyncStatus.LockOwner:
  165.                        
  166.                         syncStatus = SyncStatus.AbortedLocked;
  167.                         break;
  168.                     case SyncStatus.RequestOwner:
  169.                        
  170.                         ThreadPool.UnsafeQueueUserWorkItem(s_AbortWrapper, m_LockedRequest);
  171.                         syncStatus = SyncStatus.AbortedLocked;
  172.                         m_LockedRequest = null;
  173.                         break;
  174.                 }
  175.             }
  176.         }
  177.         // End of locking helper methods.
  178.        
  179.        
  180.        
  181.         // The lock is always held while these three are modified.
  182.         internal bool AutomaticallyDetectSettings {
  183.             set {
  184.                 if (automaticallyDetectSettings != value) {
  185.                     state = AutoWebProxyState.Uninitialized;
  186.                     automaticallyDetectSettings = value;
  187.                 }
  188.             }
  189.         }
  190.        
  191.         internal Uri AutomaticConfigurationScript {
  192.             set {
  193.                 if (!object.Equals(automaticConfigurationScript, value)) {
  194.                     automaticConfigurationScript = value;
  195.                    
  196.                     {
  197.                         state = AutoWebProxyState.Uninitialized;
  198.                     }
  199.                 }
  200.             }
  201.         }
  202.        
  203.        
  204.         // from wininet.h
  205.         //
  206.         // #define INTERNET_MAX_PATH_LENGTH 2048
  207.         // #define INTERNET_MAX_PROTOCOL_NAME "gopher" // longest protocol name
  208.         // #define INTERNET_MAX_URL_LENGTH ((sizeof(INTERNET_MAX_PROTOCOL_NAME) - 1) \
  209.         // + sizeof("://") \
  210.         // + INTERNET_MAX_PATH_LENGTH)
  211.         //
  212.         private const int MaximumProxyStringLength = 2058;
  213.        
  214.         /// <devdoc>
  215.         /// <para>
  216.         /// Called to discover script location. This performs
  217.         /// autodetection using the method specified in the detectFlags.
  218.         /// </para>
  219.         /// </devdoc>
  220.         unsafe private static Uri SafeDetectAutoProxyUrl(uint discoveryMethod)
  221.         {
  222.             Uri autoProxy = null;
  223.            
  224.            
  225.             return autoProxy;
  226.         }
  227.        
  228.         internal StringCollection GetProxies(Uri destination, bool returnFirstOnly, out AutoWebProxyState autoWebProxyState)
  229.         {
  230.             int syncStatus = SyncStatus.Unlocked;
  231.             return GetProxies(destination, returnFirstOnly, out autoWebProxyState, ref syncStatus);
  232.         }
  233.        
  234.         internal StringCollection GetProxies(Uri destination, bool returnFirstOnly, out AutoWebProxyState autoWebProxyState, ref int syncStatus)
  235.         {
  236.             GlobalLog.Print("AutoWebProxyScriptEngine#" + ValidationHelper.HashString(this) + "::GetProxies() state:" + ValidationHelper.ToString(state));
  237.            
  238.            
  239.             if (state == AutoWebProxyState.DiscoveryFailure) {
  240.                 // No engine will be available anyway, shortcut the call.
  241.                 autoWebProxyState = state;
  242.                 return null;
  243.             }
  244.            
  245.             // This whole thing has to be locked, both to prevent simultaneous downloading / compilation, and
  246.             // because the script isn't threadsafe.
  247.             string scriptReturn = null;
  248.             try {
  249.                 EnterLock(ref syncStatus);
  250.                 if (syncStatus != SyncStatus.LockOwner) {
  251.                     // This is typically because a download got aborted.
  252.                     autoWebProxyState = AutoWebProxyState.DownloadFailure;
  253.                     return null;
  254.                 }
  255.                
  256.                 autoWebProxyState = EnsureEngineAvailable(ref syncStatus);
  257.                 if (autoWebProxyState != AutoWebProxyState.CompilationSuccess) {
  258.                     // the script can't run, say we're not ready and bypass
  259.                     return null;
  260.                 }
  261.                 autoWebProxyState = AutoWebProxyState.ExecutionFailure;
  262.                 try {
  263.                     scriptReturn = scriptInstance.FindProxyForURL(destination.ToString(), destination.Host);
  264.                     autoWebProxyState = AutoWebProxyState.ExecutionSuccess;
  265.                     GlobalLog.Print("AutoWebProxyScriptEngine#" + ValidationHelper.HashString(this) + "::GetProxies() calling ExecuteFindProxyForURL() for destination:" + ValidationHelper.ToString(destination) + " returned scriptReturn:" + ValidationHelper.ToString(scriptReturn));
  266.                 }
  267.                 catch (Exception exception) {
  268.                     if (NclUtilities.IsFatal(exception))
  269.                         throw;
  270.                     if (Logging.On)
  271.                         Logging.PrintWarning(Logging.Web, SR.GetString(SR.net_log_proxy_script_execution_error, exception));
  272.                     GlobalLog.Print("AutoWebProxyScriptEngine#" + ValidationHelper.HashString(this) + "::GetProxies() calling ExecuteFindProxyForURL() for destination:" + ValidationHelper.ToString(destination) + " threw:" + ValidationHelper.ToString(exception));
  273.                 }
  274.             }
  275.             finally {
  276.                 ExitLock(ref syncStatus);
  277.             }
  278.            
  279.             if (autoWebProxyState == AutoWebProxyState.ExecutionFailure) {
  280.                 // the script failed at runtime, say we're not ready and bypass
  281.                 return null;
  282.             }
  283.             StringCollection proxies = ParseScriptReturn(scriptReturn, destination, returnFirstOnly);
  284.             GlobalLog.Print("AutoWebProxyScriptEngine#" + ValidationHelper.HashString(this) + "::GetProxies() proxies:" + ValidationHelper.ToString(proxies));
  285.             return proxies;
  286.         }
  287.        
  288.         /// <devdoc>
  289.         /// <para>
  290.         /// Ensures that (if state is AutoWebProxyState.CompilationSuccess) there is an engine available to execute script.
  291.         /// Figures out the script location (might discover if needed).
  292.         /// Calls DownloadAndCompile().
  293.         /// </para>
  294.         /// </devdoc>
  295.         private AutoWebProxyState EnsureEngineAvailable(ref int syncStatus)
  296.         {
  297.             GlobalLog.Enter("AutoWebProxyScriptEngine#" + ValidationHelper.HashString(this) + "::EnsureEngineAvailable");
  298.             AutoWebProxyScriptWrapper newScriptInstance;
  299.            
  300.             if (state == AutoWebProxyState.Uninitialized || engineScriptLocation == null) {
  301.                
  302.                 // Either Auto-Detect wasn't enabled or something failed with it. Try the manual script location.
  303.                 if (automaticConfigurationScript != null) {
  304.                     GlobalLog.Print("AutoWebProxyScriptEngine#" + ValidationHelper.HashString(this) + "::EnsureEngineAvailable() using automaticConfigurationScript:" + ValidationHelper.ToString(automaticConfigurationScript) + " engineScriptLocation:" + ValidationHelper.ToString(engineScriptLocation));
  305.                     state = AutoWebProxyState.DiscoverySuccess;
  306.                     if (automaticConfigurationScript.Equals(engineScriptLocation)) {
  307.                         state = AutoWebProxyState.CompilationSuccess;
  308.                         GlobalLog.Leave("AutoWebProxyScriptEngine#" + ValidationHelper.HashString(this) + "::EnsureEngineAvailable", ValidationHelper.ToString(state));
  309.                         return state;
  310.                     }
  311.                     state = DownloadAndCompile(automaticConfigurationScript, out newScriptInstance, ref syncStatus);
  312.                     if (state == AutoWebProxyState.CompilationSuccess) {
  313.                         UpdateScriptInstance(newScriptInstance);
  314.                         engineScriptLocation = automaticConfigurationScript;
  315.                         GlobalLog.Leave("AutoWebProxyScriptEngine#" + ValidationHelper.HashString(this) + "::EnsureEngineAvailable", ValidationHelper.ToString(state));
  316.                         return state;
  317.                     }
  318.                 }
  319.             }
  320.             else {
  321.                 // We always want to call DownloadAndCompile to check the expiration.
  322.                 GlobalLog.Print("AutoWebProxyScriptEngine#" + ValidationHelper.HashString(this) + "::EnsureEngineAvailable() state:" + state + " engineScriptLocation:" + ValidationHelper.ToString(engineScriptLocation));
  323.                 state = AutoWebProxyState.DiscoverySuccess;
  324.                 state = DownloadAndCompile(engineScriptLocation, out newScriptInstance, ref syncStatus);
  325.                 if (state == AutoWebProxyState.CompilationSuccess) {
  326.                     UpdateScriptInstance(newScriptInstance);
  327.                     GlobalLog.Leave("AutoWebProxyScriptEngine#" + ValidationHelper.HashString(this) + "::EnsureEngineAvailable", ValidationHelper.ToString(state));
  328.                     return state;
  329.                 }
  330.                
  331.                 // There's still an opportunity to fail over to the automaticConfigurationScript.
  332.                 if (!engineScriptLocation.Equals(automaticConfigurationScript)) {
  333.                     GlobalLog.Print("AutoWebProxyScriptEngine#" + ValidationHelper.HashString(this) + "::EnsureEngineAvailable() Update failed. Falling back to automaticConfigurationScript:" + ValidationHelper.ToString(automaticConfigurationScript));
  334.                     state = AutoWebProxyState.DiscoverySuccess;
  335.                     state = DownloadAndCompile(automaticConfigurationScript, out newScriptInstance, ref syncStatus);
  336.                     if (state == AutoWebProxyState.CompilationSuccess) {
  337.                         UpdateScriptInstance(newScriptInstance);
  338.                         engineScriptLocation = automaticConfigurationScript;
  339.                         GlobalLog.Leave("AutoWebProxyScriptEngine#" + ValidationHelper.HashString(this) + "::EnsureEngineAvailable", ValidationHelper.ToString(state));
  340.                         return state;
  341.                     }
  342.                 }
  343.             }
  344.            
  345.             // Everything failed. Set this instance to mostly-dead. It will wake up again if there's a reg/connectoid change.
  346.             GlobalLog.Print("AutoWebProxyScriptEngine#" + ValidationHelper.HashString(this) + "::EnsureEngineAvailable() All failed.");
  347.             state = AutoWebProxyState.DiscoveryFailure;
  348.             UpdateScriptInstance(null);
  349.             engineScriptLocation = null;
  350.            
  351.             GlobalLog.Leave("AutoWebProxyScriptEngine#" + ValidationHelper.HashString(this) + "::EnsureEngineAvailable", ValidationHelper.ToString(state));
  352.             return state;
  353.         }
  354.        
  355.         void UpdateScriptInstance(AutoWebProxyScriptWrapper newScriptInstance)
  356.         {
  357.             GlobalLog.Print("AutoWebProxyScriptEngine#" + ValidationHelper.HashString(this) + "::UpdateScriptInstance() updating scriptInstance#" + ValidationHelper.HashString(scriptInstance) + " to newScriptInstance#" + ValidationHelper.HashString(newScriptInstance));
  358.            
  359.             if (scriptInstance == newScriptInstance) {
  360.                 return;
  361.             }
  362.            
  363.             if (scriptInstance != null) {
  364.                 GlobalLog.Print("AutoWebProxyScriptEngine#" + ValidationHelper.HashString(this) + "::UpdateScriptInstance() Closing engine.");
  365.                 scriptInstance.Close();
  366.             }
  367.             scriptInstance = newScriptInstance;
  368.         }
  369.        
  370.         /// <devdoc>
  371.         /// <para>
  372.         /// Downloads and compiles the script from a given Uri.
  373.         /// This code can be called by config for a downloaded control, we need to assert.
  374.         /// This code is called holding the lock.
  375.         /// </para>
  376.         /// </devdoc>
  377.         private AutoWebProxyState DownloadAndCompile(Uri location, out AutoWebProxyScriptWrapper newScriptInstance, ref int syncStatus)
  378.         {
  379.             GlobalLog.Print("AutoWebProxyScriptEngine#" + ValidationHelper.HashString(this) + "::DownloadAndCompile() location:" + ValidationHelper.ToString(location));
  380.             AutoWebProxyState newState = AutoWebProxyState.DownloadFailure;
  381.             WebResponse response = null;
  382.             TimerThread.Timer timer = null;
  383.             newScriptInstance = null;
  384.            
  385.             // Can't assert this in declarative form (DCR?). This Assert() is needed to be able to create the request to download the proxy script.
  386.             ExceptionHelper.WebPermissionUnrestricted.Assert();
  387.             try {
  388.                 // here we have a reentrance issue due to config load.
  389.                 WebRequest request = WebRequest.Create(location);
  390.                 request.Timeout = Timeout.Infinite;
  391.                 request.CachePolicy = new RequestCachePolicy(RequestCacheLevel.Default);
  392.                 request.ConnectionGroupName = "__WebProxyScript";
  393.                
  394.                 // We have an opportunity here, if caching is disabled AppDomain-wide, to override it with a
  395.                 // custom, trivial cache-provider to get a similar semantic.
  396.                 //
  397.                 // We also want to have a backup caching key in the case when IE has locked an expired script response
  398.                 //
  399.                 if (request.CacheProtocol != null) {
  400.                     GlobalLog.Print("AutoWebProxyScriptEngine#" + ValidationHelper.HashString(this) + "::DownloadAndCompile() Using backup caching.");
  401.                     request.CacheProtocol = new RequestCacheProtocol(backupCache, request.CacheProtocol.Validator);
  402.                 }
  403.                
  404.                 HttpWebRequest httpWebRequest = request as HttpWebRequest;
  405.                 if (httpWebRequest != null) {
  406.                     httpWebRequest.Accept = "*/*";
  407.                     httpWebRequest.UserAgent = this.GetType().FullName + "/" + Environment.Version;
  408.                     httpWebRequest.KeepAlive = false;
  409.                     httpWebRequest.Pipelined = false;
  410.                     httpWebRequest.InternalConnectionGroup = true;
  411.                 }
  412.                 else {
  413.                     FtpWebRequest ftpWebRequest = request as FtpWebRequest;
  414.                     if (ftpWebRequest != null) {
  415.                         ftpWebRequest.KeepAlive = false;
  416.                     }
  417.                 }
  418.                
  419.                 // Use no proxy, default cache - initiate the download.
  420.                 request.Proxy = null;
  421.                 request.Credentials = webProxy.Credentials;
  422.                
  423.                 // Set this up with the abortable lock to abort this too.
  424.                 LockRequest(request, ref syncStatus);
  425.                 if (syncStatus != SyncStatus.RequestOwner) {
  426.                     throw new WebException(NetRes.GetWebStatusString("net_requestaborted", WebExceptionStatus.RequestCanceled), WebExceptionStatus.RequestCanceled);
  427.                 }
  428.                
  429.                 // Use our own timeout timer so that it can encompass the whole request, not just the headers.
  430.                 if (s_TimerQueue == null) {
  431.                     s_TimerQueue = TimerThread.GetOrCreateQueue(SettingsSectionInternal.Section.DownloadTimeout);
  432.                 }
  433.                 timer = s_TimerQueue.CreateTimer(s_TimerCallback, request);
  434.                 response = request.GetResponse();
  435.                
  436.                 // Check Last Modified.
  437.                 DateTime lastModified = DateTime.MinValue;
  438.                 HttpWebResponse httpResponse = response as HttpWebResponse;
  439.                 if (httpResponse != null) {
  440.                     lastModified = httpResponse.LastModified;
  441.                 }
  442.                 else {
  443.                     FtpWebResponse ftpResponse = response as FtpWebResponse;
  444.                     if (ftpResponse != null) {
  445.                         lastModified = ftpResponse.LastModified;
  446.                     }
  447.                 }
  448.                 GlobalLog.Print("AutoWebProxyScriptEngine#" + ValidationHelper.HashString(this) + "::DownloadAndCompile() lastModified:" + lastModified.ToString() + " (script):" + (scriptInstance == null ? "(null)" : scriptInstance.LastModified.ToString()));
  449.                 if (scriptInstance != null && lastModified != DateTime.MinValue && scriptInstance.LastModified == lastModified) {
  450.                     newScriptInstance = scriptInstance;
  451.                     newState = AutoWebProxyState.CompilationSuccess;
  452.                 }
  453.                 else {
  454.                     string scriptBody = null;
  455.                     byte[] scriptBuffer = null;
  456.                     using (Stream responseStream = response.GetResponseStream()) {
  457.                         SingleItemRequestCache.ReadOnlyStream ros = responseStream as SingleItemRequestCache.ReadOnlyStream;
  458.                         if (ros != null) {
  459.                             scriptBuffer = ros.Buffer;
  460.                         }
  461.                         if (scriptInstance != null && scriptBuffer != null && scriptBuffer == scriptInstance.Buffer) {
  462.                             scriptInstance.LastModified = lastModified;
  463.                             newScriptInstance = scriptInstance;
  464.                             newState = AutoWebProxyState.CompilationSuccess;
  465.                             GlobalLog.Print("AutoWebProxyScriptEngine#" + ValidationHelper.HashString(this) + "::DownloadAndCompile() Buffer matched - reusing engine.");
  466.                         }
  467.                         else {
  468.                             using (StreamReader streamReader = new StreamReader(responseStream)) {
  469.                                 scriptBody = streamReader.ReadToEnd();
  470.                             }
  471.                         }
  472.                     }
  473.                    
  474.