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

  1. //------------------------------------------------------------------------------
  2. // <copyright file="_AutoWebProxyScriptHelper.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. #pragma warning disable 618
  16. #define AUTOPROXY_MANAGED_JSCRIPT
  17. namespace System.Net
  18. {
  19.     #if AUTOPROXY_MANAGED_JSCRIPT
  20.     using System.Security.Permissions;
  21.     #endif
  22.     using System.Net.NetworkInformation;
  23.     using System.Text;
  24.     using System.Text.RegularExpressions;
  25.     using System.Globalization;
  26.     using System.Reflection;
  27.     using System.Runtime.InteropServices;
  28.     using System.Net.Sockets;
  29.    
  30.     /// <summary>
  31.     /// Provides a set of functions that can be called by the JS script. There are based on
  32.     /// an earlier API set that is used for these networking scripts.
  33.     /// for a description of the API see:
  34.     /// http://home.netscape.com/eng/mozilla/2.0/relnotes/demo/proxy-live.html
  35.     /// </summary>
  36.     #if !AUTOPROXY_MANAGED_JSCRIPT
  37.     [ComVisible(true)]
  38.     [ClassInterface(ClassInterfaceType.AutoDispatch)]
  39.     public sealed class WebProxyScriptHelper
  40.     {
  41.         internal WebProxyScriptHelper()
  42.         {
  43.         }
  44.         #else
  45.         internal class WebProxyScriptHelper : IReflect
  46.         {
  47.             private class MyMethodInfo : MethodInfo
  48.             {
  49.                 string name;
  50.                 // used by JScript
  51.                 public MyMethodInfo(string name) : base()
  52.                 {
  53.                     GlobalLog.Print("MyMethodInfo::.ctor() name:" + name);
  54.                     this.name = name;
  55.                 }
  56.                 // used by JScript
  57.                 public override Type ReturnType {
  58.                     get {
  59.                         GlobalLog.Print("MyMethodInfo::ReturnType()");
  60.                         Type type = null;
  61.                         if (string.Compare(name, "isPlainHostName", StringComparison.Ordinal) == 0) {
  62.                             type = typeof(bool);
  63.                         }
  64.                         else if (string.Compare(name, "dnsDomainIs", StringComparison.Ordinal) == 0) {
  65.                             type = typeof(bool);
  66.                         }
  67.                         else if (string.Compare(name, "localHostOrDomainIs", StringComparison.Ordinal) == 0) {
  68.                             type = typeof(bool);
  69.                         }
  70.                         else if (string.Compare(name, "isResolvable", StringComparison.Ordinal) == 0) {
  71.                             type = typeof(bool);
  72.                         }
  73.                         else if (string.Compare(name, "dnsResolve", StringComparison.Ordinal) == 0) {
  74.                             type = typeof(string);
  75.                         }
  76.                         else if (string.Compare(name, "myIpAddress", StringComparison.Ordinal) == 0) {
  77.                             type = typeof(string);
  78.                         }
  79.                         else if (string.Compare(name, "dnsDomainLevels", StringComparison.Ordinal) == 0) {
  80.                             type = typeof(int);
  81.                         }
  82.                         else if (string.Compare(name, "isInNet", StringComparison.Ordinal) == 0) {
  83.                             type = typeof(bool);
  84.                         }
  85.                         else if (string.Compare(name, "shExpMatch", StringComparison.Ordinal) == 0) {
  86.                             type = typeof(bool);
  87.                         }
  88.                         else if (string.Compare(name, "weekdayRange", StringComparison.Ordinal) == 0) {
  89.                             type = typeof(bool);
  90.                         }
  91.                         GlobalLog.Print("MyMethodInfo::ReturnType() name:" + name + " type:" + type.FullName);
  92.                         return type;
  93.                     }
  94.                 }
  95.                 // used by JScript
  96.                 public override ICustomAttributeProvider ReturnTypeCustomAttributes {
  97.                     get {
  98.                         GlobalLog.Print("MyMethodInfo::ReturnTypeCustomAttributes()");
  99.                         return null;
  100.                     }
  101.                 }
  102.                 public override RuntimeMethodHandle MethodHandle {
  103.                     get {
  104.                         GlobalLog.Print("MyMethodInfo::MethodHandle()");
  105.                         return new RuntimeMethodHandle();
  106.                     }
  107.                 }
  108.                 public override MethodAttributes Attributes {
  109.                     get {
  110.                         GlobalLog.Print("MyMethodInfo::Attributes()");
  111.                         return MethodAttributes.Public;
  112.                     }
  113.                 }
  114.                 public override string Name {
  115.                     get {
  116.                         GlobalLog.Print("MyMethodInfo::Name()");
  117.                         return name;
  118.                     }
  119.                 }
  120.                 // used by JScript
  121.                 public override Type DeclaringType {
  122.                     get {
  123.                         GlobalLog.Print("MyMethodInfo::DeclaringType()");
  124.                         return typeof(MyMethodInfo);
  125.                     }
  126.                 }
  127.                 public override Type ReflectedType {
  128.                     get {
  129.                         GlobalLog.Print("MyMethodInfo::ReflectedType()");
  130.                         return null;
  131.                     }
  132.                 }
  133.                 public override object[] GetCustomAttributes(bool inherit)
  134.                 {
  135.                     GlobalLog.Print("MyMethodInfo::GetCustomAttributes() inherit:" + inherit);
  136.                     return null;
  137.                 }
  138.                 public override object[] GetCustomAttributes(Type type, bool inherit)
  139.                 {
  140.                     GlobalLog.Print("MyMethodInfo::GetCustomAttributes() inherit:" + inherit);
  141.                     return null;
  142.                 }
  143.                 public override bool IsDefined(Type type, bool inherit)
  144.                 {
  145.                     GlobalLog.Print("MyMethodInfo::IsDefined() type:" + type.FullName + " inherit:" + inherit);
  146.                     return type.Equals(typeof(WebProxyScriptHelper));
  147.                 }
  148.                 // used by JScript
  149.                 public override object Invoke(object target, BindingFlags bindingAttr, Binder binder, object[] args, CultureInfo culture)
  150.                 {
  151.                     GlobalLog.Print("MyMethodInfo::Invoke() target:" + target);
  152.                     return typeof(WebProxyScriptHelper).GetMethod(name, (BindingFlags)unchecked(-1)).Invoke(target, (BindingFlags)unchecked(-1), binder, args, culture);
  153.                 }
  154.                 public override ParameterInfo[] GetParameters()
  155.                 {
  156.                     GlobalLog.Print("MyMethodInfo::GetParameters() name:" + name);
  157.                     ParameterInfo[] pars = typeof(WebProxyScriptHelper).GetMethod(name, (BindingFlags)unchecked(-1)).GetParameters();
  158.                     GlobalLog.Print("MyMethodInfo::GetParameters() returning pars.Length:" + pars.Length);
  159.                     return pars;
  160.                 }
  161.                 public override MethodImplAttributes GetMethodImplementationFlags()
  162.                 {
  163.                     GlobalLog.Print("MyMethodInfo::GetMethodImplementationFlags()");
  164.                     return MethodImplAttributes.IL;
  165.                 }
  166.                 public override MethodInfo GetBaseDefinition()
  167.                 {
  168.                     GlobalLog.Print("MyMethodInfo::GetBaseDefinition()");
  169.                     return null;
  170.                 }
  171.                
  172.                
  173.                 public override Module Module {
  174.                     get { return GetType().Module; }
  175.                 }
  176.             }
  177.             MethodInfo IReflect.GetMethod(string name, BindingFlags bindingAttr, Binder binder, Type[] types, ParameterModifier[] modifiers)
  178.             {
  179.                 GlobalLog.Print("WebProxyScriptHelper::IReflect() GetMethod(1) name:" + ValidationHelper.ToString(name) + " bindingAttr:" + bindingAttr);
  180.                 return null;
  181.             }
  182.             MethodInfo IReflect.GetMethod(string name, BindingFlags bindingAttr)
  183.             {
  184.                 GlobalLog.Print("WebProxyScriptHelper::IReflect() GetMethod(2) name:" + ValidationHelper.ToString(name) + " bindingAttr:" + bindingAttr);
  185.                 return null;
  186.             }
  187.             MethodInfo[] IReflect.GetMethods(BindingFlags bindingAttr)
  188.             {
  189.                 GlobalLog.Print("WebProxyScriptHelper::IReflect() GetMethods() bindingAttr:" + bindingAttr);
  190.                 return new MethodInfo[0];
  191.             }
  192.             FieldInfo IReflect.GetField(string name, BindingFlags bindingAttr)
  193.             {
  194.                 GlobalLog.Print("WebProxyScriptHelper::IReflect() GetField() name:" + ValidationHelper.ToString(name) + " bindingAttr:" + bindingAttr);
  195.                 return null;
  196.             }
  197.             FieldInfo[] IReflect.GetFields(BindingFlags bindingAttr)
  198.             {
  199.                 GlobalLog.Print("WebProxyScriptHelper::IReflect() GetFields() bindingAttr:" + bindingAttr);
  200.                 return new FieldInfo[0];
  201.             }
  202.             PropertyInfo IReflect.GetProperty(string name, BindingFlags bindingAttr)
  203.             {
  204.                 GlobalLog.Print("WebProxyScriptHelper::IReflect() GetProperty(1) name:" + ValidationHelper.ToString(name) + " bindingAttr:" + bindingAttr);
  205.                 return null;
  206.             }
  207.             PropertyInfo IReflect.GetProperty(string name, BindingFlags bindingAttr, Binder binder, Type returnType, Type[] types, ParameterModifier[] modifiers)
  208.             {
  209.                 GlobalLog.Print("WebProxyScriptHelper::IReflect() GetProperty(2) name:" + ValidationHelper.ToString(name) + " bindingAttr:" + bindingAttr);
  210.                 return null;
  211.             }
  212.             PropertyInfo[] IReflect.GetProperties(BindingFlags bindingAttr)
  213.             {
  214.                 GlobalLog.Print("WebProxyScriptHelper::IReflect() GetProperties() bindingAttr:" + bindingAttr);
  215.                 return new PropertyInfo[0];
  216.             }
  217.             // used by JScript
  218.             MemberInfo[] IReflect.GetMember(string name, BindingFlags bindingAttr)
  219.             {
  220.                 GlobalLog.Print("WebProxyScriptHelper::IReflect() GetMember() name:" + ValidationHelper.ToString(name) + " bindingAttr:" + bindingAttr);
  221.                 return new MemberInfo[] {new MyMethodInfo(name)};
  222.             }
  223.             MemberInfo[] IReflect.GetMembers(BindingFlags bindingAttr)
  224.             {
  225.                 GlobalLog.Print("WebProxyScriptHelper::IReflect() GetMembers() bindingAttr:" + bindingAttr);
  226.                 return new MemberInfo[0];
  227.             }
  228.             object IReflect.InvokeMember(string name, BindingFlags bindingAttr, Binder binder, object target, object[] args, ParameterModifier[] modifiers, CultureInfo culture, string[] namedParameters)
  229.             {
  230.                 GlobalLog.Print("WebProxyScriptHelper::IReflect() InvokeMember() name:" + ValidationHelper.ToString(name) + " bindingAttr:" + bindingAttr);
  231.                 return null;
  232.             }
  233.             Type IReflect.UnderlyingSystemType {
  234.                 get {
  235.                     GlobalLog.Print("WebProxyScriptHelper::IReflect() UnderlyingSystemType_get()");
  236.                     return null;
  237.                 }
  238.             }
  239.             #endif
  240.            
  241.             public bool isPlainHostName(string hostName)
  242.             {
  243.                 GlobalLog.Print("WebProxyScriptHelper::isPlainHostName() hostName:" + ValidationHelper.ToString(hostName));
  244.                 if (hostName == null) {
  245.                     if (Logging.On)
  246.                         Logging.PrintWarning(Logging.Web, SR.GetString(SR.net_log_proxy_called_with_null_parameter, "WebProxyScriptHelper.isPlainHostName()", "hostName"));
  247.                     throw new ArgumentNullException("hostName");
  248.                 }
  249.                 return hostName.IndexOf('.') == -1;
  250.             }
  251.            
  252.             public bool dnsDomainIs(string host, string domain)
  253.             {
  254.                 GlobalLog.Print("WebProxyScriptHelper::dnsDomainIs() host:" + ValidationHelper.ToString(host) + " domain:" + ValidationHelper.ToString(domain));
  255.                 if (host == null) {
  256.                     if (Logging.On)
  257.                         Logging.PrintWarning(Logging.Web, SR.GetString(SR.net_log_proxy_called_with_null_parameter, "WebProxyScriptHelper.dnsDomainIs()", "host"));
  258.                     throw new ArgumentNullException("host");
  259.                 }
  260.                 if (domain == null) {
  261.                     if (Logging.On)
  262.                         Logging.PrintWarning(Logging.Web, SR.GetString(SR.net_log_proxy_called_with_null_parameter, "WebProxyScriptHelper.dnsDomainIs()", "domain"));
  263.                     throw new ArgumentNullException("domain");
  264.                 }
  265.                 int index = host.LastIndexOf(domain);
  266.                 return index != -1 && (index + domain.Length) == host.Length;
  267.             }
  268.            
  269.             /// <devdoc>
  270.             /// <para>
  271.             /// This is a strange function, if its not a local hostname
  272.             /// we do a straight compare against the passed in domain
  273.             /// string. If its not a direct match, then its false,
  274.             /// even if the root of the domain/hostname are the same.
  275.             /// </para>
  276.             /// </devdoc>
  277.             public bool localHostOrDomainIs(string host, string hostDom)
  278.             {
  279.                 GlobalLog.Print("WebProxyScriptHelper::localHostOrDomainIs() host:" + ValidationHelper.ToString(host) + " hostDom:" + ValidationHelper.ToString(hostDom));
  280.                 if (host == null) {
  281.                     if (Logging.On)
  282.                         Logging.PrintWarning(Logging.Web, SR.GetString(SR.net_log_proxy_called_with_null_parameter, "WebProxyScriptHelper.localHostOrDomainIs()", "host"));
  283.                     throw new ArgumentNullException("host");
  284.                 }
  285.                 if (hostDom == null) {
  286.                     if (Logging.On)
  287.                         Logging.PrintWarning(Logging.Web, SR.GetString(SR.net_log_proxy_called_with_null_parameter, "WebProxyScriptHelper.localHostOrDomainIs()", "hostDom"));
  288.                     throw new ArgumentNullException("hostDom");
  289.                 }
  290.                 if (isPlainHostName(host)) {
  291.                     int index = hostDom.IndexOf('.');
  292.                     if (index > 0) {
  293.                         hostDom = hostDom.Substring(0, index);
  294.                     }
  295.                 }
  296.                 return string.Compare(host, hostDom, StringComparison.OrdinalIgnoreCase) == 0;
  297.             }
  298.            
  299.             public bool isResolvable(string host)
  300.             {
  301.                 GlobalLog.Print("WebProxyScriptHelper::isResolvable() host:" + ValidationHelper.ToString(host));
  302.                 if (host == null) {
  303.                     if (Logging.On)
  304.                         Logging.PrintWarning(Logging.Web, SR.GetString(SR.net_log_proxy_called_with_null_parameter, "WebProxyScriptHelper.isResolvable()", "host"));
  305.                     throw new ArgumentNullException("host");
  306.                 }
  307.                 IPHostEntry ipHostEntry = null;
  308.                 try {
  309.                     ipHostEntry = Dns.InternalGetHostByName(host);
  310.                 }
  311.                 catch {
  312.                 }
  313.                 if (ipHostEntry == null) {
  314.                     return false;
  315.                 }
  316.                 for (int i = 0; i < ipHostEntry.AddressList.Length; i++) {
  317.                     if (ipHostEntry.AddressList[i].AddressFamily == AddressFamily.InterNetwork) {
  318.                         return true;
  319.                     }
  320.                 }
  321.                 return false;
  322.             }
  323.            
  324.             public string dnsResolve(string host)
  325.             {
  326.                 GlobalLog.Print("WebProxyScriptHelper::dnsResolve() host:" + ValidationHelper.ToString(host));
  327.                 if (host == null) {
  328.                     if (Logging.On)
  329.                         Logging.PrintWarning(Logging.Web, SR.GetString(SR.net_log_proxy_called_with_null_parameter, "WebProxyScriptHelper.dnsResolve()", "host"));
  330.                     throw new ArgumentNullException("host");
  331.                 }
  332.                 IPHostEntry ipHostEntry = null;
  333.                 try {
  334.                     ipHostEntry = Dns.InternalGetHostByName(host);
  335.                 }
  336.                 catch {
  337.                 }
  338.                 if (ipHostEntry == null) {
  339.                     return string.Empty;
  340.                 }
  341.                 for (int i = 0; i < ipHostEntry.AddressList.Length; i++) {
  342.                     if (ipHostEntry.AddressList[i].AddressFamily == AddressFamily.InterNetwork) {
  343.                         return ipHostEntry.AddressList[i].ToString();
  344.                     }
  345.                 }
  346.                 return string.Empty;
  347.             }
  348.            
  349.             public string myIpAddress()
  350.             {
  351.                 GlobalLog.Print("WebProxyScriptHelper::myIpAddress()");
  352.                 IPAddress[] ipAddresses = NclUtilities.LocalAddresses;
  353.                 for (int i = 0; i < ipAddresses.Length; i++) {
  354.                     if (!IPAddress.IsLoopback(ipAddresses[i]) && ipAddresses[i].AddressFamily == AddressFamily.InterNetwork) {
  355.                         return ipAddresses[i].ToString();
  356.                     }
  357.                 }
  358.                 return string.Empty;
  359.             }
  360.            
  361.             public int dnsDomainLevels(string host)
  362.             {
  363.                 GlobalLog.Print("WebProxyScriptHelper::dnsDomainLevels() host:" + ValidationHelper.ToString(host));
  364.                 if (host == null) {
  365.                     if (Logging.On)
  366.                         Logging.PrintWarning(Logging.Web, SR.GetString(SR.net_log_proxy_called_with_null_parameter, "WebProxyScriptHelper.dnsDomainLevels()", "host"));
  367.                     throw new ArgumentNullException("host");
  368.                 }
  369.                 int index = 0;
  370.                 int domainCount = 0;
  371.                 while ((index = host.IndexOf('.', index)) != -1) {
  372.                     domainCount++;
  373.                     index++;
  374.                 }
  375.                 return domainCount;
  376.             }
  377.            
  378.             public bool isInNet(string host, string pattern, string mask)
  379.             {
  380.                 GlobalLog.Print("WebProxyScriptHelper::isInNet() host:" + ValidationHelper.ToString(host) + " pattern:" + ValidationHelper.ToString(pattern) + " mask:" + ValidationHelper.ToString(mask));
  381.                 if (host == null) {
  382.                     if (Logging.On)
  383.                         Logging.PrintWarning(Logging.Web, SR.GetString(SR.net_log_proxy_called_with_null_parameter, "WebProxyScriptHelper.isInNet()", "host"));
  384.                     throw new ArgumentNullException("host");
  385.                 }
  386.                 if (pattern == null) {
  387.                     if (Logging.On)
  388.                         Logging.PrintWarning(Logging.Web, SR.GetString(SR.net_log_proxy_called_with_null_parameter, "WebProxyScriptHelper.isInNet()", "pattern"));
  389.                     throw new ArgumentNullException("pattern");
  390.                 }
  391.                 if (mask == null) {
  392.                     if (Logging.On)
  393.                         Logging.PrintWarning(Logging.Web, SR.GetString(SR.net_log_proxy_called_with_null_parameter, "WebProxyScriptHelper.isInNet()", "mask"));
  394.                     throw new ArgumentNullException("mask");
  395.                 }
  396.                 try {
  397.                     IPAddress hostAddress = IPAddress.Parse(host);
  398.                     IPAddress patternAddress = IPAddress.Parse(pattern);
  399.                     IPAddress maskAddress = IPAddress.Parse(mask);
  400.                    
  401.                     byte[] maskAddressBytes = maskAddress.GetAddressBytes();
  402.                     byte[] hostAddressBytes = hostAddress.GetAddressBytes();
  403.                     byte[] patternAddressBytes = patternAddress.GetAddressBytes();
  404.                     if (maskAddressBytes.Length != hostAddressBytes.Length || maskAddressBytes.Length != patternAddressBytes.Length) {
  405.                         return false;
  406.                     }
  407.                     for (int i = 0; i < maskAddressBytes.Length; i++) {
  408.                         if ((patternAddressBytes[i] & maskAddressBytes[i]) != (hostAddressBytes[i] & maskAddressBytes[i])) {
  409.                             return false;
  410.                         }
  411.                     }
  412.                 }
  413.                 catch {
  414.                     return false;
  415.                 }
  416.                 return true;
  417.             }
  418.            
  419.             // See bug 87334 for details on the implementation.
  420.             public bool shExpMatch(string host, string pattern)
  421.             {
  422.                 GlobalLog.Print("WebProxyScriptHelper::shExpMatch() host:" + ValidationHelper.ToString(host) + " pattern:" + ValidationHelper.ToString(pattern));
  423.                 if (host == null) {
  424.                     if (Logging.On)
  425.                         Logging.PrintWarning(Logging.Web, SR.GetString(SR.net_log_proxy_called_with_null_parameter, "WebProxyScriptHelper.shExpMatch()", "host"));
  426.                     throw new ArgumentNullException("host");
  427.                 }
  428.                 if (pattern == null) {
  429.                     if (Logging.On)
  430.                         Logging.PrintWarning(Logging.Web, SR.GetString(SR.net_log_proxy_called_with_null_parameter, "WebProxyScriptHelper.shExpMatch()", "pattern"));
  431.                     throw new ArgumentNullException("pattern");
  432.                 }
  433.                
  434.                 try {
  435.                     // This can throw - treat as no match.
  436.                     ShellExpression exp = new ShellExpression(pattern);
  437.                     return exp.IsMatch(host);
  438.                 }
  439.                 catch (FormatException) {
  440.                     return false;
  441.                 }
  442.             }
  443.            
  444.             public bool weekdayRange(string wd1,             [Optional()]
  445. object wd2,             [Optional()]
  446. object gmt)
  447.             {
  448.                 GlobalLog.Print("WebProxyScriptHelper::weekdayRange() wd1:" + ValidationHelper.ToString(wd1) + " wd2:" + ValidationHelper.ToString(wd2) + " gmt:" + ValidationHelper.ToString(gmt));
  449.                 if (wd1 == null) {
  450.                     if (Logging.On)
  451.                         Logging.PrintWarning(Logging.Web, SR.GetString(SR.net_log_proxy_called_with_null_parameter, "WebProxyScriptHelper.weekdayRange()", "wd1"));
  452.                     throw new ArgumentNullException("wd1");
  453.                 }
  454.                 string _gmt = null;
  455.                 string _wd2 = null;
  456.                 if (gmt != null && gmt != DBNull.Value && gmt != Missing.Value) {
  457.                     _gmt = gmt as string;
  458.                     if (_gmt == null) {
  459.                         throw new ArgumentException(SR.GetString(SR.net_param_not_string, gmt.GetType().FullName), "gmt");
  460.                     }
  461.                 }
  462.                 if (wd2 != null && wd2 != DBNull.Value && gmt != Missing.Value) {
  463.                     _wd2 = wd2 as string;
  464.                     if (_wd2 == null) {
  465.                         throw new ArgumentException(SR.GetString(SR.net_param_not_string, wd2.GetType().FullName), "wd2");
  466.                     }
  467.                 }
  468.                 if (_gmt != null) {
  469.                     if (!isGMT(_gmt)) {
  470.                         if (Logging.On)
  471.                             Logging.PrintWarning(Logging.Web, SR.GetString(SR.net_log_proxy_called_with_null_parameter, "WebProxyScriptHelper.weekdayRange()", "gmt"));
  472.                         throw new ArgumentException(SR.GetString(SR.net_proxy_not_gmt), "gmt");
  473.                     }
  474.                     return weekdayRangeInternal(DateTime.UtcNow, dayOfWeek(wd1), dayOfWeek(_wd2));
  475.                 }
  476.                 if (_wd2 != null) {
  477.                     if (isGMT(_wd2)) {
  478.                         return weekdayRangeInternal(DateTime.UtcNow, dayOfWeek(wd1), dayOfWeek(wd1));
  479.                     }
  480.                     return weekdayRangeInternal(DateTime.Now, dayOfWeek(wd1), dayOfWeek(_wd2));
  481.                 }
  482.                 return weekdayRangeInternal(DateTime.Now, dayOfWeek(wd1), dayOfWeek(wd1));
  483.             }
  484.            
  485.             private static bool isGMT(string gmt)
  486.             {
  487.                 return string.Compare(gmt, "GMT", StringComparison.OrdinalIgnoreCase) == 0;
  488.             }
  489.            
  490.             private static DayOfWeek dayOfWeek(string weekDay)
  491.             {
  492.                 if (weekDay != null && weekDay.Length == 3) {
  493.                     if (weekDay[0] == 'T' || weekDay[0] == 't') {
  494.                         if ((weekDay[1] == 'U' || weekDay[1] == 'u') && (weekDay[2] == 'E' || weekDay[2] == 'e')) {
  495.                             return DayOfWeek.Tuesday;
  496.                         }
  497.                         if ((weekDay[1] == 'H' || weekDay[1] == 'h') && (weekDay[2] == 'U' || weekDay[2] == 'u')) {
  498.                             return DayOfWeek.Thursday;
  499.                         }
  500.                     }
  501.                     if (weekDay[0] == 'S' || weekDay[0] == 's') {
  502.                         if ((weekDay[1] == 'U' || weekDay[1] == 'u') && (weekDay[2] == 'N' || weekDay[2] == 'n')) {
  503.                             return DayOfWeek.Sunday;
  504.                         }
  505.                         if ((weekDay[1] == 'A' || weekDay[1] == 'a') && (weekDay[2] == 'T' || weekDay[2] == 't')) {
  506.                             return DayOfWeek.Saturday;
  507.                         }
  508.                     }
  509.                     if ((weekDay[0] == 'M' || weekDay[0] == 'm') && (weekDay[1] == 'O' || weekDay[1] == 'o') && (weekDay[2] == 'N' || weekDay[2] == 'n')) {
  510.                         return DayOfWeek.Monday;
  511.                     }
  512.                     if ((weekDay[0] == 'W' || weekDay[0] == 'w') && (weekDay[1] == 'E' || weekDay[1] == 'e') && (weekDay[2] == 'D' || weekDay[2] == 'd')) {
  513.                         return DayOfWeek.Wednesday;
  514.                     }
  515.                     if ((weekDay[0] == 'F' || weekDay[0] == 'f') && (weekDay[1] == 'R' || weekDay[1] == 'r') && (weekDay[2] == 'I' || weekDay[2] == 'i')) {
  516.                         return DayOfWeek.Friday;
  517.                     }
  518.                 }
  519.                 return (DayOfWeek)unchecked(-1);
  520.             }
  521.            
  522.             private static bool weekdayRangeInternal(DateTime now, DayOfWeek wd1, DayOfWeek wd2)
  523.             {
  524.                 if (wd1 < 0 || wd2 < 0) {
  525.                     if (Logging.On)
  526.                         Logging.PrintWarning(Logging.Web, SR.GetString(SR.net_log_proxy_called_with_invalid_parameter, "WebProxyScriptHelper.weekdayRange()"));
  527.                     throw new ArgumentException(SR.GetString(SR.net_proxy_invalid_dayofweek), wd1 < 0 ? "wd1" : "wd2");
  528.                 }
  529.                 if (wd1 <= wd2) {
  530.                     return wd1 <= now.DayOfWeek && now.DayOfWeek <= wd2;
  531.                 }
  532.                 return wd2 >= now.DayOfWeek || now.DayOfWeek >= wd1;
  533.             }
  534.         }
  535.     }
  536. }

Developer Fusion