The Labs \ Source Viewer \ SSCLI \ System.Net \ ProxyRegBlob

  1. //------------------------------------------------------------------------------
  2. // <copyright file="_ProxyRegBlob.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. //------------------------------------------------------------------------------
  15. namespace System.Net
  16. {
  17.     using System;
  18.     using System.Security.Permissions;
  19.     using System.Globalization;
  20.     using System.Text;
  21.     using System.Collections;
  22.     using System.Collections.Specialized;
  23.     using System.Net.Sockets;
  24.     using System.Threading;
  25.     using System.Runtime.InteropServices;
  26.     using Microsoft.Win32;
  27.     using System.Runtime.Versioning;
  28.    
  29.     internal class ProxyRegBlob
  30.     {
  31.        
  32.         private static string ReadConfigString(string ConfigName)
  33.         {
  34.             const int parameterValueLength = 255;
  35.             StringBuilder parameterValue = new StringBuilder(parameterValueLength);
  36.             bool rc = UnsafeNclNativeMethods.FetchConfigurationString(true, ConfigName, parameterValue, parameterValueLength);
  37.             if (rc) {
  38.                 return parameterValue.ToString();
  39.             }
  40.             return "";
  41.         }
  42.        
  43.         //
  44.         // Parses out a string from IE and turns it into a URI
  45.         //
  46.         private static Uri ParseProxyUri(string proxyString, bool validate)
  47.         {
  48.             if (validate) {
  49.                 if (proxyString.Length == 0) {
  50.                     return null;
  51.                 }
  52.                 if (proxyString.IndexOf('=') != -1) {
  53.                     return null;
  54.                 }
  55.             }
  56.             if (proxyString.IndexOf("://") == -1) {
  57.                 proxyString = "http://" + proxyString;
  58.             }
  59.             return new Uri(proxyString);
  60.         }
  61.        
  62.         //
  63.         // Builds a hashtable containing the protocol and proxy URI to use for it.
  64.         //
  65.         private static Hashtable ParseProtocolProxies(string proxyListString)
  66.         {
  67.             if (proxyListString.Length == 0) {
  68.                 return null;
  69.             }
  70.             // parse something like "http=http://http-proxy;https=http://https-proxy;ftp=http://ftp-proxy"
  71.             char[] splitChars = new char[] {';', '='};
  72.             string[] proxyListStrings = proxyListString.Split(splitChars);
  73.             bool protocolPass = true;
  74.             string protocolString = null;
  75.             Hashtable proxyListHashTable = new Hashtable(CaseInsensitiveAscii.StaticInstance);
  76.             foreach (string elementString in proxyListStrings) {
  77.                 string elementString2 = elementString.Trim().ToLower(CultureInfo.InvariantCulture);
  78.                 if (protocolPass) {
  79.                     protocolString = elementString2;
  80.                 }
  81.                 else {
  82.                     proxyListHashTable[protocolString] = ParseProxyUri(elementString2, false);
  83.                 }
  84.                 protocolPass = !protocolPass;
  85.             }
  86.             if (proxyListHashTable.Count == 0) {
  87.                 return null;
  88.             }
  89.             return proxyListHashTable;
  90.         }
  91.        
  92.         //
  93.         // Converts a simple IE regular expresion string into one
  94.         // that is compatible with Regex escape sequences.
  95.         //
  96.         private static string BypassStringEscape(string bypassString)
  97.         {
  98.             StringBuilder escapedBypass = new StringBuilder();
  99.             // (\, *, +, ?, |, {, [, (,), ^, $, ., #, and whitespace) are reserved
  100.             foreach (char c in bypassString) {
  101.                 if (c == '\\' || c == '.' || c == '?' || c == '(' || c == ')' || c == '|' || c == '^' || c == '+' || c == '{' || c == '[' || c == '$' || c == '#') {
  102.                     escapedBypass.Append('\\');
  103.                 }
  104.                 else if (c == '*') {
  105.                     escapedBypass.Append('.');
  106.                 }
  107.                 escapedBypass.Append(c);
  108.             }
  109.             escapedBypass.Append('$');
  110.             return escapedBypass.ToString();
  111.         }
  112.        
  113.        
  114.         //
  115.         // Parses out a string of bypass list entries and coverts it to Regex's that can be used
  116.         // to match against.
  117.         //
  118.         private static ArrayList ParseBypassList(string bypassListString, out bool bypassOnLocal)
  119.         {
  120.             char[] splitChars = new char[] {';'};
  121.             string[] bypassListStrings = bypassListString.Split(splitChars);
  122.             bypassOnLocal = false;
  123.             if (bypassListStrings.Length == 0) {
  124.                 return null;
  125.             }
  126.             ArrayList bypassList = null;
  127.             foreach (string bypassString in bypassListStrings) {
  128.                 if (bypassString != null) {
  129.                     string bypassString2 = bypassString.Trim();
  130.                     if (bypassString2.Length > 0) {
  131.                         if (string.Compare(bypassString2, "<local>", StringComparison.OrdinalIgnoreCase) == 0) {
  132.                             bypassOnLocal = true;
  133.                         }
  134.                         else {
  135.                             bypassString2 = BypassStringEscape(bypassString2);
  136.                             if (bypassList == null) {
  137.                                 bypassList = new ArrayList();
  138.                             }
  139.                             GlobalLog.Print("ProxyRegBlob::ParseBypassList() bypassList.Count:" + bypassList.Count + " adding:" + ValidationHelper.ToString(bypassString2));
  140.                             if (!bypassList.Contains(bypassString2)) {
  141.                                 bypassList.Add(bypassString2);
  142.                                 GlobalLog.Print("ProxyRegBlob::ParseBypassList() bypassList.Count:" + bypassList.Count + " added:" + ValidationHelper.ToString(bypassString2));
  143.                             }
  144.                         }
  145.                     }
  146.                 }
  147.             }
  148.             return bypassList;
  149.         }
  150.        
  151.         //
  152.         // Updates an instance of WbeProxy with the proxy settings from IE for:
  153.         // the current user and a given connectoid.
  154.         //
  155.         [ResourceExposure(ResourceScope.Machine)]
  156.         // Check scoping on this SafeRegistryHandle
  157.         [ResourceConsumption(ResourceScope.Machine)]
  158.         static internal WebProxyData GetWebProxyData(string connectoid)
  159.         {
  160.             GlobalLog.Print("ProxyRegBlob::GetWebProxyData() connectoid:" + ValidationHelper.ToString(connectoid));
  161.             WebProxyData webProxyData = new WebProxyData();
  162.             Hashtable proxyHashTable = null;
  163.             Uri address = null;
  164.            
  165.             string proxyAddressString = ReadConfigString("ProxyUri");
  166.             string proxyBypassString = ReadConfigString("ProxyBypass");
  167.             try {
  168.                 address = ParseProxyUri(proxyAddressString, true);
  169.                 if (address == null) {
  170.                     proxyHashTable = ParseProtocolProxies(proxyAddressString);
  171.                 }
  172.                 if ((address != null || proxyHashTable != null) && proxyBypassString != null) {
  173.                     webProxyData.bypassList = ParseBypassList(proxyBypassString, out webProxyData.bypassOnLocal);
  174.                 }
  175.                 // success if we reach here
  176.             }
  177.             catch {
  178.             }
  179.            
  180.             if (proxyHashTable != null) {
  181.                 address = proxyHashTable["http"] as Uri;
  182.             }
  183.             webProxyData.proxyAddress = address;
  184.            
  185.             return webProxyData;
  186.         }
  187.        
  188.     }
  189. }

Developer Fusion