public static SafeFreeCredentials AcquireDefaultCredential(SSPIInterface SecModule, string package, CredentialUse intent)
{
GlobalLog.Print("SSPIWrapper::AcquireDefaultCredential(): using " + package);
if (Logging.On)
{
Logging.PrintInfo(Logging.Web,
"AcquireDefaultCredential(" +
"package = " + package + ", " +
"intent = " + intent + ")");
}
SafeFreeCredentials outCredential = null;
int errorCode = SecModule.AcquireDefaultCredential(package, intent, out outCredential);
if (errorCode != 0)
{
#if TRAVE
GlobalLog.Print("SSPIWrapper::AcquireDefaultCredential(): error " + SecureChannel.MapSecurityStatus((uint)errorCode));
#endif
if (Logging.On)
{
Logging.PrintError(Logging.Web, SR.GetString(SR.net_log_operation_failed_with_error, "AcquireDefaultCredential()", String.Format(CultureInfo.CurrentCulture, "0X{0:X}", errorCode)));
}
throw new Win32Exception(errorCode);
}
return(outCredential);
}
public static SafeFreeCredentials AcquireCredentialsHandle(SSPIInterface secModule, string package, Interop.Secur32.CredentialUse intent, ref Interop.Secur32.AuthIdentity authdata)
{
GlobalLog.Print("SSPIWrapper::AcquireCredentialsHandle#2(): using " + package);
if (Logging.On)
{
Logging.PrintInfo(Logging.Web,
"AcquireCredentialsHandle(" +
"package = " + package + ", " +
"intent = " + intent + ", " +
"authdata = " + authdata + ")");
}
SafeFreeCredentials credentialsHandle = null;
int errorCode = secModule.AcquireCredentialsHandle(package,
intent,
ref authdata,
out credentialsHandle
);
if (errorCode != 0)
{
#if TRACE_VERBOSE
GlobalLog.Print("SSPIWrapper::AcquireCredentialsHandle#2(): error " + Interop.MapSecurityStatus((uint)errorCode));
#endif
if (Logging.On)
{
Logging.PrintError(Logging.Web, SR.Format(SR.net_log_operation_failed_with_error, "AcquireCredentialsHandle()", String.Format(CultureInfo.CurrentCulture, "0X{0:X}", errorCode)));
}
throw new Win32Exception(errorCode);
}
return(credentialsHandle);
}
public static SafeFreeCredentials AcquireCredentialsHandle(SSPIInterface secModule, string package, Interop.Secur32.CredentialUse intent, ref SafeSspiAuthDataHandle authdata)
{
if (Logging.On)
{
Logging.PrintInfo(Logging.Web,
"AcquireCredentialsHandle(" +
"package = " + package + ", " +
"intent = " + intent + ", " +
"authdata = " + authdata + ")");
}
SafeFreeCredentials credentialsHandle = null;
int errorCode = secModule.AcquireCredentialsHandle(package, intent, ref authdata, out credentialsHandle);
if (errorCode != 0)
{
if (Logging.On)
{
Logging.PrintError(Logging.Web, SR.Format(SR.net_log_operation_failed_with_error, "AcquireCredentialsHandle()", String.Format(CultureInfo.CurrentCulture, "0X{0:X}", errorCode)));
}
throw new Win32Exception(errorCode);
}
return(credentialsHandle);
}
private int GetProxies(Uri destination, Uri scriptLocation, out string proxyListString)
{
int errorCode = 0;
proxyListString = null;
UnsafeNclNativeMethods.WinHttp.WINHTTP_AUTOPROXY_OPTIONS autoProxyOptions =
new UnsafeNclNativeMethods.WinHttp.WINHTTP_AUTOPROXY_OPTIONS();
// Always try to download the PAC file without authentication. If we turn auth. on, the WinHttp
// service will create a new session for every request (performance/memory implications).
// Therefore we only turn auto-logon on if it is really needed.
autoProxyOptions.AutoLogonIfChallenged = false;
if (scriptLocation == null)
{
// Use auto-discovery to find the script location.
autoProxyOptions.Flags = UnsafeNclNativeMethods.WinHttp.AutoProxyFlags.AutoDetect;
autoProxyOptions.AutoConfigUrl = null;
autoProxyOptions.AutoDetectFlags = UnsafeNclNativeMethods.WinHttp.AutoDetectType.Dhcp |
UnsafeNclNativeMethods.WinHttp.AutoDetectType.DnsA;
}
else
{
// Use the provided script location for the PAC file.
autoProxyOptions.Flags = UnsafeNclNativeMethods.WinHttp.AutoProxyFlags.AutoProxyConfigUrl;
autoProxyOptions.AutoConfigUrl = scriptLocation.ToString();
autoProxyOptions.AutoDetectFlags = UnsafeNclNativeMethods.WinHttp.AutoDetectType.None;
}
if (!WinHttpGetProxyForUrl(destination.ToString(), ref autoProxyOptions, out proxyListString))
{
errorCode = GetLastWin32Error();
// If the PAC file can't be downloaded because auth. was required, we check if the
// credentials are set; if so, then we try again using auto-logon.
// Note that by default webProxy.Credentials will be null. The user needs to set
// <defaultProxy useDefaultCredentials="true"> in the config file, in order for
// webProxy.Credentials to be set to DefaultNetworkCredentials.
if ((errorCode == (int)UnsafeNclNativeMethods.WinHttp.ErrorCodes.LoginFailure) &&
(Engine.Credentials != null))
{
// Now we need to try again, this time by enabling auto-logon.
autoProxyOptions.AutoLogonIfChallenged = true;
if (!WinHttpGetProxyForUrl(destination.ToString(), ref autoProxyOptions,
out proxyListString))
{
errorCode = GetLastWin32Error();
}
}
if (Logging.On)
{
Logging.PrintError(Logging.Web, SR.GetString(SR.net_log_proxy_winhttp_getproxy_failed, destination, errorCode));
}
}
return(errorCode);
}
private static void CreateInstance()
{
instance = new NetworkingPerfCounters();
if ((instance.Enabled && !ThreadPool.QueueUserWorkItem(new WaitCallback(instance.Initialize))) && Logging.On)
{
Logging.PrintError(Logging.Web, SR.GetString("net_perfcounter_cant_queue_workitem"));
}
}
private static WindowsInstallationType GetWindowsInstallType()
{
WindowsInstallationType unknown;
try
{
using (RegistryKey key = Registry.LocalMachine.OpenSubKey(@"Software\Microsoft\Windows NT\CurrentVersion"))
{
string str = key.GetValue("InstallationType") as string;
if (string.IsNullOrEmpty(str))
{
if (Logging.On)
{
Logging.PrintWarning(Logging.Web, SR.GetString("net_empty_osinstalltype", new object[] { @"Software\Microsoft\Windows NT\CurrentVersion\InstallationType" }));
}
return(WindowsInstallationType.Unknown);
}
if (string.Compare(str, "Client", StringComparison.OrdinalIgnoreCase) == 0)
{
return(WindowsInstallationType.Client);
}
if (string.Compare(str, "Server", StringComparison.OrdinalIgnoreCase) == 0)
{
return(WindowsInstallationType.Server);
}
if (string.Compare(str, "Server Core", StringComparison.OrdinalIgnoreCase) == 0)
{
return(WindowsInstallationType.ServerCore);
}
if (string.Compare(str, "Embedded", StringComparison.OrdinalIgnoreCase) == 0)
{
return(WindowsInstallationType.Embedded);
}
if (Logging.On)
{
Logging.PrintError(Logging.Web, SR.GetString("net_unknown_osinstalltype", new object[] { str }));
}
unknown = WindowsInstallationType.Unknown;
}
}
catch (UnauthorizedAccessException exception)
{
if (Logging.On)
{
Logging.PrintWarning(Logging.Web, SR.GetString("net_cant_determine_osinstalltype", new object[] { @"Software\Microsoft\Windows NT\CurrentVersion", exception.Message }));
}
unknown = WindowsInstallationType.Unknown;
}
catch (SecurityException exception2)
{
if (Logging.On)
{
Logging.PrintWarning(Logging.Web, SR.GetString("net_cant_determine_osinstalltype", new object[] { @"Software\Microsoft\Windows NT\CurrentVersion", exception2.Message }));
}
unknown = WindowsInstallationType.Unknown;
}
return(unknown);
}
private static FormatException CreateInvalidProxyStringException(string originalProxyString)
{
string message = SR.GetString(SR.net_proxy_invalid_url_format, originalProxyString);
if (Logging.On)
{
Logging.PrintError(Logging.Web, message);
}
return(new FormatException(message));
}
private static FormatException CreateInvalidProxyStringException(string originalProxyString)
{
string msg = SR.GetString("net_proxy_invalid_url_format", new object[] { originalProxyString });
if (Logging.On)
{
Logging.PrintError(Logging.Web, msg);
}
return(new FormatException(msg));
}
private static void CreateInstance()
{
instance = new NetworkingPerfCounters();
if (instance.Enabled)
{
// as recommended by the perf. counter team: initialize perf. counters in background thread
// since initialization may take a long time. Therefore we should not block.
if (!ThreadPool.QueueUserWorkItem(instance.Initialize))
{
if (Logging.On)
{
Logging.PrintError(Logging.Web, SR.GetString(SR.net_perfcounter_cant_queue_workitem));
}
}
}
}
private static string computeSecret(HttpDigestChallenge challenge, string username, string password)
{
if ((challenge.Algorithm == null) || (string.Compare(challenge.Algorithm, "md5", StringComparison.OrdinalIgnoreCase) == 0))
{
return(username + ":" + challenge.Realm + ":" + password);
}
if (string.Compare(challenge.Algorithm, "md5-sess", StringComparison.OrdinalIgnoreCase) == 0)
{
return(hashString(username + ":" + challenge.Realm + ":" + password, challenge.MD5provider) + ":" + challenge.Nonce + ":" + challenge.ClientNonce);
}
if (Logging.On)
{
Logging.PrintError(Logging.Web, SR.GetString("net_log_digest_hash_algorithm_not_supported", new object[] { challenge.Algorithm }));
}
return(null);
}
internal bool Fire()
{
if (this.m_TimerState == TimerState.Ready)
{
int tickCount = Environment.TickCount;
if (TimerThread.IsTickBetween(base.StartTime, base.Expiration, tickCount))
{
return(false);
}
bool flag = false;
lock (this.m_QueueLock)
{
if (this.m_TimerState == TimerState.Ready)
{
this.m_TimerState = TimerState.Fired;
this.Next.Prev = this.Prev;
this.Prev.Next = this.Next;
this.Next = null;
this.Prev = null;
flag = this.m_Callback != null;
}
}
if (flag)
{
try
{
TimerThread.Callback callback = this.m_Callback;
object context = this.m_Context;
this.m_Callback = null;
this.m_Context = null;
callback(this, tickCount, context);
}
catch (Exception exception)
{
if (NclUtilities.IsFatal(exception))
{
throw;
}
if (Logging.On)
{
Logging.PrintError(Logging.Web, "TimerThreadTimer#" + base.StartTime.ToString(NumberFormatInfo.InvariantInfo) + "::Fire() - " + SR.GetString("net_log_exception_in_callback", new object[] { exception }));
}
}
}
}
return(true);
}
private static bool IsAddressListLoopback(IPAddress[] addressList)
{
IPAddress[] localAddresses = null;
try
{
localAddresses = NclUtilities.LocalAddresses;
}
catch (Exception exception)
{
if (NclUtilities.IsFatal(exception))
{
throw;
}
if (Logging.On)
{
Logging.PrintError(Logging.Web, SR.GetString("net_log_retrieving_localhost_exception", new object[] { exception }));
Logging.PrintWarning(Logging.Web, SR.GetString("net_log_resolved_servicepoint_may_not_be_remote_server"));
}
}
int index = 0;
while (index < addressList.Length)
{
if (!IPAddress.IsLoopback(addressList[index]))
{
if (localAddresses == null)
{
break;
}
int num2 = 0;
while (num2 < localAddresses.Length)
{
if (addressList[index].Equals(localAddresses[num2]))
{
break;
}
num2++;
}
if (num2 >= localAddresses.Length)
{
break;
}
}
index++;
}
return(index == addressList.Length);
}
public static SafeFreeCredentials AcquireDefaultCredential(SSPIInterface SecModule, string package, CredentialUse intent)
{
if (Logging.On)
{
Logging.PrintInfo(Logging.Web, string.Concat(new object[] { "AcquireDefaultCredential(package = ", package, ", intent = ", intent, ")" }));
}
SafeFreeCredentials outCredential = null;
int error = SecModule.AcquireDefaultCredential(package, intent, out outCredential);
if (error == 0)
{
return(outCredential);
}
if (Logging.On)
{
Logging.PrintError(Logging.Web, SR.GetString("net_log_operation_failed_with_error", new object[] { "AcquireDefaultCredential()", string.Format(CultureInfo.CurrentCulture, "0X{0:X}", new object[] { error }) }));
}
throw new Win32Exception(error);
}
//
// Parses out a string from IE and turns it into a URI
//
private static Uri ParseProxyUri(string proxyString)
{
Debug.Assert(!string.IsNullOrEmpty(proxyString));
if (proxyString.IndexOf("://") == -1)
{
proxyString = "http://" + proxyString;
}
try {
return(new Uri(proxyString));
}
catch (UriFormatException e) {
if (Logging.On)
{
Logging.PrintError(Logging.Web, e.Message);
}
throw CreateInvalidProxyStringException(proxyString);
}
}
private static Uri ParseProxyUri(string proxyString)
{
Uri uri;
if (proxyString.IndexOf("://") == -1)
{
proxyString = "http://" + proxyString;
}
try
{
uri = new Uri(proxyString);
}
catch (UriFormatException exception)
{
if (Logging.On)
{
Logging.PrintError(Logging.Web, exception.Message);
}
throw CreateInvalidProxyStringException(proxyString);
}
return(uri);
}
private int GetProxies(Uri destination, Uri scriptLocation, out string proxyListString)
{
int num = 0;
proxyListString = null;
UnsafeNclNativeMethods.WinHttp.WINHTTP_AUTOPROXY_OPTIONS autoProxyOptions = new UnsafeNclNativeMethods.WinHttp.WINHTTP_AUTOPROXY_OPTIONS {
AutoLogonIfChallenged = false
};
if (scriptLocation == null)
{
autoProxyOptions.Flags = UnsafeNclNativeMethods.WinHttp.AutoProxyFlags.AutoDetect;
autoProxyOptions.AutoConfigUrl = null;
autoProxyOptions.AutoDetectFlags = UnsafeNclNativeMethods.WinHttp.AutoDetectType.DnsA | UnsafeNclNativeMethods.WinHttp.AutoDetectType.Dhcp;
}
else
{
autoProxyOptions.Flags = UnsafeNclNativeMethods.WinHttp.AutoProxyFlags.AutoProxyConfigUrl;
autoProxyOptions.AutoConfigUrl = scriptLocation.ToString();
autoProxyOptions.AutoDetectFlags = UnsafeNclNativeMethods.WinHttp.AutoDetectType.None;
}
if (!this.WinHttpGetProxyForUrl(destination.ToString(), ref autoProxyOptions, out proxyListString))
{
num = GetLastWin32Error();
if ((num == 0x2eef) && (base.Engine.Credentials != null))
{
autoProxyOptions.AutoLogonIfChallenged = true;
if (!this.WinHttpGetProxyForUrl(destination.ToString(), ref autoProxyOptions, out proxyListString))
{
num = GetLastWin32Error();
}
}
if (Logging.On)
{
Logging.PrintError(Logging.Web, SR.GetString("net_log_proxy_winhttp_getproxy_failed", new object[] { destination, num }));
}
}
return(num);
}
public WinHttpWebProxyFinder(AutoWebProxyScriptEngine engine)
: base(engine)
{
// Don't specify a user agent and dont' specify proxy settings. This is the same behavior WinHttp
// uses when downloading the PAC file.
session = UnsafeNclNativeMethods.WinHttp.WinHttpOpen(null,
UnsafeNclNativeMethods.WinHttp.AccessType.NoProxy, null, null, 0);
// Don't throw on error, just log the error information. This is consistent with how auto-proxy
// works: we never throw on error (discovery, download, execution errors).
if (session == null || session.IsInvalid)
{
int errorCode = GetLastWin32Error();
if (Logging.On)
{
Logging.PrintError(Logging.Web, SR.GetString(SR.net_log_proxy_winhttp_cant_open_session, errorCode));
}
}
else
{
// The default download-timeout is 1 min.
// WinHTTP will use the sum of all four timeouts provided in WinHttpSetTimeouts as the
// actual timeout. Setting a value to 0 means "infinite".
// Since we don't provide the ability to specify finegrained timeouts like WinHttp does,
// we simply apply the configured timeout to all four WinHttp timeouts.
int timeout = SettingsSectionInternal.Section.DownloadTimeout;
if (!UnsafeNclNativeMethods.WinHttp.WinHttpSetTimeouts(session, timeout, timeout, timeout, timeout))
{
// We weren't able to set the timeouts. Just log and continue.
int errorCode = GetLastWin32Error();
if (Logging.On)
{
Logging.PrintError(Logging.Web, SR.GetString(SR.net_log_proxy_winhttp_timeout_error, errorCode));
}
}
}
}
private SafeFreeCredentials AcquireCredentialsHandle(string package, bool isServer, Interop.Secur32.SecureCredential scc)
{
GlobalLog.Print("SSPIWrapper::AcquireCredentialsHandle#3(): using " + package);
if (Logging.On)
{
Logging.PrintInfo(Logging.Web,
"AcquireCredentialsHandle(" +
"package = " + package + ", " +
"IsInBoundCred = " + isServer + ", " +
"scc = " + scc + ")");
}
SafeFreeCredentials outCredential = null;
int errorCode = AcquireCredentialsHandle(
package,
isServer,
ref scc,
out outCredential
);
if (errorCode != 0)
{
#if TRACE_VERBOSE
GlobalLog.Print("SSPIWrapper::AcquireCredentialsHandle#3(): error " + Interop.MapSecurityStatus((uint)errorCode));
#endif
if (Logging.On)
{
Logging.PrintError(Logging.Web, SR.Format(SR.net_log_operation_failed_with_error, "AcquireCredentialsHandle()", String.Format(CultureInfo.CurrentCulture, "0X{0:X}", errorCode)));
}
throw new Win32Exception(errorCode);
}
#if TRACE_VERBOSE
GlobalLog.Print("SSPIWrapper::AcquireCredentialsHandle#3(): cred handle = " + outCredential.ToString());
#endif
return(outCredential);
}
public WinHttpWebProxyFinder(AutoWebProxyScriptEngine engine) : base(engine)
{
this.session = UnsafeNclNativeMethods.WinHttp.WinHttpOpen(null, UnsafeNclNativeMethods.WinHttp.AccessType.NoProxy, null, null, 0);
if ((this.session == null) || this.session.IsInvalid)
{
int num = GetLastWin32Error();
if (Logging.On)
{
Logging.PrintError(Logging.Web, SR.GetString("net_log_proxy_winhttp_cant_open_session", new object[] { num }));
}
}
else
{
int downloadTimeout = SettingsSectionInternal.Section.DownloadTimeout;
if (!UnsafeNclNativeMethods.WinHttp.WinHttpSetTimeouts(this.session, downloadTimeout, downloadTimeout, downloadTimeout, downloadTimeout))
{
int num3 = GetLastWin32Error();
if (Logging.On)
{
Logging.PrintError(Logging.Web, SR.GetString("net_log_proxy_winhttp_timeout_error", new object[] { num3 }));
}
}
}
}
//
// Security: We temporarily reset thread token to open the cert store under process account.
//
internal override X509Store EnsureStoreOpened(bool isMachineStore)
{
X509Store store = isMachineStore ? s_myMachineCertStoreEx : s_myCertStoreEx;
if (store == null)
{
lock (s_syncObject)
{
store = isMachineStore ? s_myMachineCertStoreEx : s_myCertStoreEx;
if (store == null)
{
// NOTE: that if this call fails we won't keep track and the next time we enter we will try to open the store again.
StoreLocation storeLocation = isMachineStore ? StoreLocation.LocalMachine : StoreLocation.CurrentUser;
store = new X509Store(StoreName.My, storeLocation);
try
{
// For app-compat We want to ensure the store is opened under the **process** account.
try
{
WindowsIdentity.RunImpersonated(SafeAccessTokenHandle.InvalidHandle, () =>
{
store.Open(OpenFlags.ReadOnly | OpenFlags.OpenExistingOnly);
GlobalLog.Print("SecureChannel::EnsureStoreOpened() storeLocation:" + storeLocation + " returned store:" + store.GetHashCode().ToString("x"));
});
}
catch
{
throw;
}
if (isMachineStore)
{
s_myMachineCertStoreEx = store;
}
else
{
s_myCertStoreEx = store;
}
return(store);
}
catch (Exception exception)
{
if (exception is CryptographicException || exception is SecurityException)
{
GlobalLog.Assert("SecureChannel::EnsureStoreOpened()", "Failed to open cert store, location:" + storeLocation + " exception:" + exception);
return(null);
}
if (Logging.On)
{
Logging.PrintError(Logging.Web, SR.Format(SR.net_log_open_store_failed, storeLocation, exception));
}
throw;
}
}
}
}
return(store);
}
private static unsafe int EncryptDecryptHelper(OP op, SSPIInterface SecModule, SafeDeleteContext context, SecurityBuffer[] input, uint sequenceNumber)
{
SecurityBufferDescriptor inputOutput = new SecurityBufferDescriptor(input.Length);
SecurityBufferStruct[] structArray = new SecurityBufferStruct[input.Length];
fixed(SecurityBufferStruct *structRef = structArray)
{
int num6;
inputOutput.UnmanagedPointer = (void *)structRef;
GCHandle[] handleArray = new GCHandle[input.Length];
byte[][] bufferArray = new byte[input.Length][];
try
{
int num2;
for (int i = 0; i < input.Length; i++)
{
SecurityBuffer buffer = input[i];
structArray[i].count = buffer.size;
structArray[i].type = buffer.type;
if ((buffer.token == null) || (buffer.token.Length == 0))
{
structArray[i].token = IntPtr.Zero;
}
else
{
handleArray[i] = GCHandle.Alloc(buffer.token, GCHandleType.Pinned);
structArray[i].token = Marshal.UnsafeAddrOfPinnedArrayElement(buffer.token, buffer.offset);
bufferArray[i] = buffer.token;
}
}
switch (op)
{
case OP.Encrypt:
num2 = SecModule.EncryptMessage(context, inputOutput, sequenceNumber);
break;
case OP.Decrypt:
num2 = SecModule.DecryptMessage(context, inputOutput, sequenceNumber);
break;
case OP.MakeSignature:
num2 = SecModule.MakeSignature(context, inputOutput, sequenceNumber);
break;
case OP.VerifySignature:
num2 = SecModule.VerifySignature(context, inputOutput, sequenceNumber);
break;
default:
throw ExceptionHelper.MethodNotImplementedException;
}
for (int j = 0; j < input.Length; j++)
{
SecurityBuffer buffer2 = input[j];
buffer2.size = structArray[j].count;
buffer2.type = structArray[j].type;
if (buffer2.size == 0)
{
buffer2.offset = 0;
buffer2.token = null;
}
else
{
int index = 0;
while (index < input.Length)
{
if (bufferArray[index] != null)
{
byte *numPtr = (byte *)Marshal.UnsafeAddrOfPinnedArrayElement(bufferArray[index], 0);
if ((((void *)structArray[j].token) >= numPtr) && ((((void *)structArray[j].token) + buffer2.size) <= (numPtr + bufferArray[index].Length)))
{
buffer2.offset = (int)((long)((((void *)structArray[j].token) - numPtr) / 1));
buffer2.token = bufferArray[index];
break;
}
}
index++;
}
if (index >= input.Length)
{
buffer2.size = 0;
buffer2.offset = 0;
buffer2.token = null;
}
}
}
if ((num2 != 0) && Logging.On)
{
if (num2 == 0x90321)
{
Logging.PrintError(Logging.Web, SR.GetString("net_log_operation_returned_something", new object[] { op, "SEC_I_RENEGOTIATE" }));
}
else
{
Logging.PrintError(Logging.Web, SR.GetString("net_log_operation_failed_with_error", new object[] { op, string.Format(CultureInfo.CurrentCulture, "0X{0:X}", new object[] { num2 }) }));
}
}
num6 = num2;
}
finally
{
for (int k = 0; k < handleArray.Length; k++)
{
if (handleArray[k].IsAllocated)
{
handleArray[k].Free();
}
}
}
return(num6);
}
}
/// <summary>
/// <para>Thread for the timer. Swallows all exceptions except ThreadAbort. If no activity occurs for a while,
/// the thread will shut down.</para>
/// </summary>
private static void ThreadProc()
{
#if DEBUG
GlobalLog.SetThreadSource(ThreadKinds.Timer);
using (GlobalLog.SetThreadKind(ThreadKinds.System | ThreadKinds.Async)) {
#endif
GlobalLog.Print("TimerThread#" + Thread.CurrentThread.ManagedThreadId.ToString() + "::ThreadProc() Start");
// t_IsTimerThread = true; -- Not used anywhere.
// Set this thread as a background thread. On AppDomain/Process shutdown, the thread will just be killed.
Thread.CurrentThread.IsBackground = true;
// Keep a permanent lock on s_Queues. This lets for example Shutdown() know when this thread isn't running.
lock (s_Queues) {
// If shutdown was recently called, abort here.
if (Interlocked.CompareExchange(ref s_ThreadState, (int)TimerThreadState.Running, (int)TimerThreadState.Running) !=
(int)TimerThreadState.Running)
{
return;
}
bool running = true;
while (running)
{
try {
s_ThreadReadyEvent.Reset();
while (true)
{
// Copy all the new queues to the real queues. Since only this thread modifies the real queues, it doesn't have to lock it.
if (s_NewQueues.Count > 0)
{
lock (s_NewQueues) {
for (LinkedListNode <WeakReference> node = s_NewQueues.First; node != null; node = s_NewQueues.First)
{
s_NewQueues.Remove(node);
s_Queues.AddLast(node);
}
}
}
int now = Environment.TickCount;
int nextTick = 0;
bool haveNextTick = false;
for (LinkedListNode <WeakReference> node = s_Queues.First; node != null; /* node = node.Next must be done in the body */)
{
TimerQueue queue = (TimerQueue)node.Value.Target;
if (queue == null)
{
LinkedListNode <WeakReference> next = node.Next;
s_Queues.Remove(node);
node = next;
continue;
}
// Fire() will always return values that should be interpreted as later than 'now' (that is, even if 'now' is
// returned, it is 0x100000000 milliseconds in the future). There's also a chance that Fire() will return a value
// intended as > 0x100000000 milliseconds from 'now'. Either case will just cause an extra scan through the timers.
int nextTickInstance;
if (queue.Fire(out nextTickInstance) && (!haveNextTick || IsTickBetween(now, nextTick, nextTickInstance)))
{
nextTick = nextTickInstance;
haveNextTick = true;
}
node = node.Next;
}
// Figure out how long to wait, taking into account how long the loop took.
// Add 15 ms to compensate for poor TickCount resolution (want to guarantee a firing).
int newNow = Environment.TickCount;
int waitDuration = haveNextTick ?
(int)(IsTickBetween(now, nextTick, newNow) ?
Math.Min(unchecked ((uint)(nextTick - newNow)), (uint)(Int32.MaxValue - c_TickCountResolution)) + c_TickCountResolution :
0) :
c_ThreadIdleTimeoutMilliseconds;
GlobalLog.Print("TimerThread#" + Thread.CurrentThread.ManagedThreadId.ToString() + "::ThreadProc() Waiting for " + waitDuration + "ms");
int waitResult = WaitHandle.WaitAny(s_ThreadEvents, waitDuration, false);
// 0 is s_ThreadShutdownEvent - die.
if (waitResult == 0)
{
GlobalLog.Print("TimerThread#" + Thread.CurrentThread.ManagedThreadId.ToString() + "::ThreadProc() Awoke, cause: Shutdown");
running = false;
break;
}
GlobalLog.Print("TimerThread#" + Thread.CurrentThread.ManagedThreadId.ToString() + "::ThreadProc() Awoke, cause: " + (waitResult == WaitHandle.WaitTimeout ? "Timeout" : "Prod"));
// If we timed out with nothing to do, shut down.
if (waitResult == WaitHandle.WaitTimeout && !haveNextTick)
{
Interlocked.CompareExchange(ref s_ThreadState, (int)TimerThreadState.Idle, (int)TimerThreadState.Running);
// There could have been one more prod between the wait and the exchange. Check, and abort if necessary.
if (s_ThreadReadyEvent.WaitOne(0, false))
{
if (Interlocked.CompareExchange(ref s_ThreadState, (int)TimerThreadState.Running, (int)TimerThreadState.Idle) ==
(int)TimerThreadState.Idle)
{
continue;
}
}
running = false;
break;
}
}
}
catch (Exception exception) {
if (NclUtilities.IsFatal(exception))
{
throw;
}
if (Logging.On)
{
Logging.PrintError(Logging.Web, "TimerThread#" + Thread.CurrentThread.ManagedThreadId.ToString(NumberFormatInfo.InvariantInfo) + "::ThreadProc() - Exception:" + exception.ToString());
}
GlobalLog.Print("TimerThread#" + Thread.CurrentThread.ManagedThreadId.ToString() + "::ThreadProc() exception: " + exception);
// The only options are to continue processing and likely enter an error-loop,
// shut down timers for this AppDomain, or shut down the AppDomain. Go with shutting
// down the AppDomain in debug, and going into a loop in retail, but try to make the
// loop somewhat slow. Note that in retail, this can only be triggered by OutOfMemory or StackOverflow,
// or an thrown within TimerThread - the rest are caught in Fire().
#if !DEBUG
Thread.Sleep(1000);
#else
throw;
#endif
}
}
}
GlobalLog.Print("TimerThread#" + Thread.CurrentThread.ManagedThreadId.ToString() + "::ThreadProc() Stop");
#if DEBUG
}
#endif
}
/// <summary>
/// <para>Fires the timer if it is still active and has expired. Returns
/// true if it can be deleted, or false if it is still timing.</para>
/// </summary>
internal bool Fire()
{
GlobalLog.Assert(m_TimerState != TimerState.Sentinel, "TimerThread#{0}::Fire()|TimerQueue tried to Fire a Sentinel.", Thread.CurrentThread.ManagedThreadId.ToString());
if (m_TimerState != TimerState.Ready)
{
return(true);
}
// Must get the current tick count within this method so it is guaranteed not to be before
// StartTime, which is set in the constructor.
int nowMilliseconds = Environment.TickCount;
if (IsTickBetween(StartTime, Expiration, nowMilliseconds))
{
GlobalLog.Print("TimerThreadTimer#" + StartTime + "::Fire() Not firing (" + StartTime + " <= " + nowMilliseconds + " < " + Expiration + ")");
return(false);
}
bool needCallback = false;
lock (m_QueueLock)
{
if (m_TimerState == TimerState.Ready)
{
GlobalLog.Print("TimerThreadTimer#" + StartTime + "::Fire() Firing (" + StartTime + " <= " + nowMilliseconds + " >= " + Expiration + ")");
m_TimerState = TimerState.Fired;
// Remove it from the list.
Next.Prev = Prev;
Prev.Next = Next;
// Doesn't need to be in the lock but is easier to have here.
Next = null;
Prev = null;
needCallback = m_Callback != null;
}
}
if (needCallback)
{
try {
Callback callback = m_Callback;
object context = m_Context;
m_Callback = null;
m_Context = null;
callback(this, nowMilliseconds, context);
}
catch (Exception exception) {
if (NclUtilities.IsFatal(exception))
{
throw;
}
if (Logging.On)
{
Logging.PrintError(Logging.Web, "TimerThreadTimer#" + StartTime.ToString(NumberFormatInfo.InvariantInfo) + "::Fire() - " + SR.GetString(SR.net_log_exception_in_callback, exception));
}
GlobalLog.Print("TimerThreadTimer#" + StartTime + "::Fire() exception in callback: " + exception);
// This thread is not allowed to go into user code, so we should never get an exception here.
// So, in debug, throw it up, killing the AppDomain. In release, we'll just ignore it.
#if DEBUG
throw;
#endif
}
}
return(true);
}
internal static HttpDigestChallenge Interpret(string challenge, int startingPoint, HttpWebRequest httpWebRequest)
{
int num2;
string str2;
HttpDigestChallenge challenge2 = new HttpDigestChallenge();
challenge2.SetFromRequest(httpWebRequest);
startingPoint = (startingPoint == -1) ? 0 : (startingPoint + DigestClient.SignatureSize);
int startIndex = startingPoint;
Label_001F:
num2 = startIndex;
int num3 = AuthenticationManager.SplitNoQuotes(challenge, ref num2);
if (num2 >= 0)
{
if (string.Compare(challenge.Substring(startIndex, num2 - startIndex), "charset", StringComparison.OrdinalIgnoreCase) == 0)
{
if (num3 < 0)
{
str2 = unquote(challenge.Substring(num2 + 1));
}
else
{
str2 = unquote(challenge.Substring(num2 + 1, (num3 - num2) - 1));
}
if (string.Compare(str2, "utf-8", StringComparison.OrdinalIgnoreCase) == 0)
{
challenge2.UTF8Charset = true;
goto Label_009E;
}
}
if (num3 >= 0)
{
startIndex = ++num3;
goto Label_001F;
}
}
Label_009E:
startIndex = startingPoint;
Label_00A0:
num2 = startIndex;
num3 = AuthenticationManager.SplitNoQuotes(challenge, ref num2);
if (num2 >= 0)
{
string name = challenge.Substring(startIndex, num2 - startIndex);
if (num3 < 0)
{
str2 = unquote(challenge.Substring(num2 + 1));
}
else
{
str2 = unquote(challenge.Substring(num2 + 1, (num3 - num2) - 1));
}
if (challenge2.UTF8Charset)
{
bool flag2 = true;
for (int i = 0; i < str2.Length; i++)
{
if (str2[i] > '\x007f')
{
flag2 = false;
break;
}
}
if (!flag2)
{
byte[] bytes = new byte[str2.Length];
for (int j = 0; j < str2.Length; j++)
{
bytes[j] = (byte)str2[j];
}
str2 = Encoding.UTF8.GetString(bytes);
}
}
bool flag = challenge2.defineAttribute(name, str2);
if ((num3 >= 0) && flag)
{
startIndex = ++num3;
goto Label_00A0;
}
}
if (challenge2.Nonce != null)
{
return(challenge2);
}
if (Logging.On)
{
Logging.PrintError(Logging.Web, SR.GetString("net_log_digest_requires_nonce"));
}
return(null);
}
private Authorization DoAuthenticate(string challenge, WebRequest webRequest, ICredentials credentials, bool preAuthenticate)
{
HttpDigestChallenge challenge2;
if (credentials == null)
{
return(null);
}
HttpWebRequest httpWebRequest = webRequest as HttpWebRequest;
NetworkCredential credential = credentials.GetCredential(httpWebRequest.ChallengedUri, Signature);
if (credential is SystemNetworkCredential)
{
if (WDigestAvailable)
{
return(this.XPDoAuthenticate(challenge, httpWebRequest, credentials, preAuthenticate));
}
return(null);
}
if (!preAuthenticate)
{
int startingPoint = AuthenticationManager.FindSubstringNotInQuotes(challenge, Signature);
if (startingPoint < 0)
{
return(null);
}
challenge2 = HttpDigest.Interpret(challenge, startingPoint, httpWebRequest);
}
else
{
challenge2 = challengeCache.Lookup(httpWebRequest.ChallengedUri.AbsoluteUri) as HttpDigestChallenge;
}
if (challenge2 == null)
{
return(null);
}
if (!CheckQOP(challenge2))
{
if (Logging.On)
{
Logging.PrintError(Logging.Web, SR.GetString("net_log_digest_qop_not_supported", new object[] { challenge2.QualityOfProtection }));
}
return(null);
}
if (preAuthenticate)
{
challenge2 = challenge2.CopyAndIncrementNonce();
challenge2.SetFromRequest(httpWebRequest);
}
if (credential == null)
{
return(null);
}
ICredentialPolicy credentialPolicy = AuthenticationManager.CredentialPolicy;
if ((credentialPolicy != null) && !credentialPolicy.ShouldSendCredential(httpWebRequest.ChallengedUri, httpWebRequest, credential, this))
{
return(null);
}
string computeSpn = httpWebRequest.CurrentAuthenticationState.GetComputeSpn(httpWebRequest);
ChannelBinding channelBinding = null;
if (httpWebRequest.CurrentAuthenticationState.TransportContext != null)
{
channelBinding = httpWebRequest.CurrentAuthenticationState.TransportContext.GetChannelBinding(ChannelBindingKind.Endpoint);
}
Authorization authorization = HttpDigest.Authenticate(challenge2, credential, computeSpn, channelBinding);
if ((!preAuthenticate && webRequest.PreAuthenticate) && (authorization != null))
{
string[] strArray = (challenge2.Domain == null) ? new string[] { httpWebRequest.ChallengedUri.GetParts(UriComponents.SchemeAndServer, UriFormat.UriEscaped) } : challenge2.Domain.Split(singleSpaceArray);
authorization.ProtectionRealm = (challenge2.Domain == null) ? null : strArray;
for (int i = 0; i < strArray.Length; i++)
{
challengeCache.Add(strArray[i], challenge2);
}
}
return(authorization);
}
public static SafeFreeCredentials AcquireDefaultCredential(SSPIInterface SecModule, string package, CredentialUse intent)
{
SafeFreeCredentials outCredential = null;
string currentIdentityKey = null;
bool isIdentityCached;
if (s_DefaultCredentialsHandleCacheEnabled)
{
currentIdentityKey = string.Format("{0}_{1}_{2}", package, intent.ToString(), WindowsIdentity.GetCurrent().Name);
isIdentityCached = s_DefaultCredentialsHandleCache.Value.TryGetValue(currentIdentityKey, out outCredential);
}
else
{
isIdentityCached = false;
}
GlobalLog.Print("SSPIWrapper::AcquireDefaultCredential(): using " + package);
if (Logging.On)
{
if (currentIdentityKey == null)
{
// We aren't using the cache but it's still useful to log the current identity for diagnostics.
currentIdentityKey = string.Format("{0}_{1}_{2}", package, intent.ToString(), WindowsIdentity.GetCurrent().Name);
}
Logging.PrintInfo(Logging.Web,
"AcquireDefaultCredential(" +
"package = " + package + ", " +
"intent = " + intent + ", " +
"identity = " + currentIdentityKey + ", " +
"cached = " + isIdentityCached + ")");
}
if (!isIdentityCached)
{
int errorCode = SecModule.AcquireDefaultCredential(package, intent, out outCredential);
if (errorCode != 0)
{
#if TRAVE
GlobalLog.Print("SSPIWrapper::AcquireDefaultCredential(): error " + SecureChannel.MapSecurityStatus((uint)errorCode));
#endif
if (Logging.On)
{
Logging.PrintError(Logging.Web, SR.GetString(SR.net_log_operation_failed_with_error, "AcquireDefaultCredential()", String.Format(CultureInfo.CurrentCulture, "0X{0:X}", errorCode)));
}
throw new Win32Exception(errorCode);
}
if (s_DefaultCredentialsHandleCacheEnabled &&
s_DefaultCredentialsHandleCache.Value.Count < s_DefaultCredentialsHandleCacheSize)
{
try {
s_DefaultCredentialsHandleCache.Value.TryAdd(currentIdentityKey, outCredential);
}
catch (OverflowException) {
// Unlikely to be thrown since it requires Int32.MaxValue items to already be in the cache.
// But we don't want to throw a new exception. So, we'll ignore this error and accept that
// the handle won't be cached.
}
}
}
return(outCredential);
}
private unsafe SecurityStatus EncryptDecryptHelper(OP op, SafeDeleteContext context, SecurityBuffer[] input, uint sequenceNumber)
{
Interop.Secur32.SecurityBufferDescriptor sdcInOut = new Interop.Secur32.SecurityBufferDescriptor(input.Length);
var unmanagedBuffer = new Interop.Secur32.SecurityBufferStruct[input.Length];
fixed(Interop.Secur32.SecurityBufferStruct *unmanagedBufferPtr = unmanagedBuffer)
{
sdcInOut.UnmanagedPointer = unmanagedBufferPtr;
GCHandle[] pinnedBuffers = new GCHandle[input.Length];
byte[][] buffers = new byte[input.Length][];
try
{
for (int i = 0; i < input.Length; i++)
{
SecurityBuffer iBuffer = input[i];
unmanagedBuffer[i].count = iBuffer.size;
unmanagedBuffer[i].type = iBuffer.type;
if (iBuffer.token == null || iBuffer.token.Length == 0)
{
unmanagedBuffer[i].token = IntPtr.Zero;
}
else
{
pinnedBuffers[i] = GCHandle.Alloc(iBuffer.token, GCHandleType.Pinned);
unmanagedBuffer[i].token = Marshal.UnsafeAddrOfPinnedArrayElement(iBuffer.token, iBuffer.offset);
buffers[i] = iBuffer.token;
}
}
// The result is written in the input Buffer passed as type=BufferType.Data.
int errorCode;
switch (op)
{
case OP.Encrypt:
errorCode = EncryptMessage(context, sdcInOut, sequenceNumber);
break;
case OP.Decrypt:
errorCode = DecryptMessage(context, sdcInOut, sequenceNumber);
break;
default: throw NotImplemented.ByDesignWithMessage(SR.net_MethodNotImplementedException);
}
// Marshalling back returned sizes / data.
for (int i = 0; i < input.Length; i++)
{
SecurityBuffer iBuffer = input[i];
iBuffer.size = unmanagedBuffer[i].count;
iBuffer.type = unmanagedBuffer[i].type;
if (iBuffer.size == 0)
{
iBuffer.offset = 0;
iBuffer.token = null;
}
else
{
checked
{
// Find the buffer this is inside of. Usually they all point inside buffer 0.
int j;
for (j = 0; j < input.Length; j++)
{
if (buffers[j] == null)
{
continue;
}
byte *bufferAddress = (byte *)Marshal.UnsafeAddrOfPinnedArrayElement(buffers[j], 0);
if ((byte *)unmanagedBuffer[i].token >= bufferAddress &&
(byte *)unmanagedBuffer[i].token + iBuffer.size <= bufferAddress + buffers[j].Length)
{
iBuffer.offset = (int)((byte *)unmanagedBuffer[i].token - bufferAddress);
iBuffer.token = buffers[j];
break;
}
}
if (j >= input.Length)
{
GlobalLog.Assert("SSPIWrapper::EncryptDecryptHelper", "Output buffer out of range.");
iBuffer.size = 0;
iBuffer.offset = 0;
iBuffer.token = null;
}
}
}
// Backup validate the new sizes.
GlobalLog.Assert(iBuffer.offset >= 0 && iBuffer.offset <= (iBuffer.token == null ? 0 : iBuffer.token.Length), "SSPIWrapper::EncryptDecryptHelper|'offset' out of range. [{0}]", iBuffer.offset);
GlobalLog.Assert(iBuffer.size >= 0 && iBuffer.size <= (iBuffer.token == null ? 0 : iBuffer.token.Length - iBuffer.offset), "SSPIWrapper::EncryptDecryptHelper|'size' out of range. [{0}]", iBuffer.size);
}
if (errorCode != 0 && Logging.On)
{
if (errorCode == 0x90321)
{
Logging.PrintError(Logging.Web, SR.Format(SR.net_log_operation_returned_something, op, "SEC_I_RENEGOTIATE"));
}
else
{
Logging.PrintError(Logging.Web, SR.Format(SR.net_log_operation_failed_with_error, op, String.Format(CultureInfo.CurrentCulture, "0X{0:X}", errorCode)));
}
}
return(MapToSecurityStatus((Interop.SecurityStatus)errorCode));
}
finally
{
for (int i = 0; i < pinnedBuffers.Length; ++i)
{
if (pinnedBuffers[i].IsAllocated)
{
pinnedBuffers[i].Free();
}
}
}
}
}
private void Initialize(object state)
{
if (Logging.On)
{
Logging.PrintInfo(Logging.Web, SR.GetString("net_perfcounter_initialization_started"));
}
new PerformanceCounterPermission(PermissionState.Unrestricted).Assert();
try
{
if (!PerformanceCounterCategory.Exists(".NET CLR Networking 4.0.0.0"))
{
if (Logging.On)
{
Logging.PrintError(Logging.Web, SR.GetString("net_perfcounter_nocategory", new object[] { ".NET CLR Networking 4.0.0.0" }));
}
}
else
{
string instanceName = GetInstanceName();
this.counters = new CounterPair[counterNames.Length];
for (int i = 0; i < counterNames.Length; i++)
{
this.counters[i] = CreateCounterPair(counterNames[i], instanceName);
}
AppDomain.CurrentDomain.DomainUnload += new EventHandler(this.UnloadEventHandler);
AppDomain.CurrentDomain.ProcessExit += new EventHandler(this.ExitEventHandler);
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(this.ExceptionEventHandler);
this.initSuccessful = true;
}
}
catch (Win32Exception exception)
{
if (Logging.On)
{
Logging.Exception(Logging.Web, "NetworkingPerfCounters", "Initialize", exception);
}
this.Cleanup();
}
catch (InvalidOperationException exception2)
{
if (Logging.On)
{
Logging.Exception(Logging.Web, "NetworkingPerfCounters", "Initialize", exception2);
}
this.Cleanup();
}
finally
{
CodeAccessPermission.RevertAssert();
this.initDone = true;
if (Logging.On)
{
if (this.initSuccessful)
{
Logging.PrintInfo(Logging.Web, SR.GetString("net_perfcounter_initialized_success"));
}
else
{
Logging.PrintInfo(Logging.Web, SR.GetString("net_perfcounter_initialized_error"));
}
}
}
}
private static void ThreadProc()
{
Thread.CurrentThread.IsBackground = true;
lock (s_Queues)
{
if (Interlocked.CompareExchange(ref s_ThreadState, 1, 1) == 1)
{
bool flag = true;
while (flag)
{
try
{
s_ThreadReadyEvent.Reset();
Label_0043:
if (s_NewQueues.Count > 0)
{
lock (s_NewQueues)
{
for (LinkedListNode <WeakReference> node = s_NewQueues.First; node != null; node = s_NewQueues.First)
{
s_NewQueues.Remove(node);
s_Queues.AddLast(node);
}
}
}
int tickCount = Environment.TickCount;
int end = 0;
bool flag3 = false;
LinkedListNode <WeakReference> first = s_Queues.First;
while (first != null)
{
TimerQueue target = (TimerQueue)first.Value.Target;
if (target == null)
{
LinkedListNode <WeakReference> next = first.Next;
s_Queues.Remove(first);
first = next;
}
else
{
int num3;
if (target.Fire(out num3) && (!flag3 || IsTickBetween(tickCount, end, num3)))
{
end = num3;
flag3 = true;
}
first = first.Next;
}
}
int comparand = Environment.TickCount;
int millisecondsTimeout = flag3 ? (IsTickBetween(tickCount, end, comparand) ? (((int)Math.Min((uint)(end - comparand), 0x7ffffff0)) + 15) : 0) : 0x7530;
int num6 = WaitHandle.WaitAny(s_ThreadEvents, millisecondsTimeout, false);
if (num6 == 0)
{
flag = false;
}
else
{
if ((num6 != 0x102) || flag3)
{
goto Label_0043;
}
Interlocked.CompareExchange(ref s_ThreadState, 0, 1);
if (s_ThreadReadyEvent.WaitOne(0, false) && (Interlocked.CompareExchange(ref s_ThreadState, 1, 0) == 0))
{
goto Label_0043;
}
flag = false;
}
continue;
}
catch (Exception exception)
{
if (NclUtilities.IsFatal(exception))
{
throw;
}
if (Logging.On)
{
Logging.PrintError(Logging.Web, "TimerThread#" + Thread.CurrentThread.ManagedThreadId.ToString(NumberFormatInfo.InvariantInfo) + "::ThreadProc() - Exception:" + exception.ToString());
}
Thread.Sleep(0x3e8);
continue;
}
}
}
}
}
private void Initialize(object state)
{
if (Logging.On)
{
Logging.PrintInfo(Logging.Web, SR.GetString(SR.net_perfcounter_initialization_started));
}
PerformanceCounterPermission perfCounterPermission = new PerformanceCounterPermission(PermissionState.Unrestricted);
perfCounterPermission.Assert();
try
{
if (!PerformanceCounterCategory.Exists(categoryName))
{
// if the perf. counter category doesn't exist, just log this information and exit.
if (Logging.On)
{
Logging.PrintError(Logging.Web, SR.GetString(SR.net_perfcounter_nocategory, categoryName));
}
return;
}
string instanceName = GetInstanceName();
Debug.Assert(counterNames.Length == Enum.GetValues(typeof(NetworkingPerfCounterName)).Length,
"The number of NetworkingPerfCounterName items must match the number of CounterNames");
// create the counters, this will check for the right permissions (false)
// means the counter is not readonly (it's read/write) and cache them while
// we're under the Assert(), which will be reverted in the finally below.
counters = new CounterPair[counterNames.Length];
for (int i = 0; i < counterNames.Length; i++)
{
counters[i] = CreateCounterPair(counterNames[i], instanceName);
}
AppDomain.CurrentDomain.DomainUnload += new EventHandler(UnloadEventHandler);
AppDomain.CurrentDomain.ProcessExit += new EventHandler(ExitEventHandler);
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(ExceptionEventHandler);
initSuccessful = true;
}
catch (Win32Exception e)
{
if (Logging.On)
{
Logging.Exception(Logging.Web, "NetworkingPerfCounters", "Initialize", e);
}
Cleanup();
return;
}
catch (InvalidOperationException e)
{
if (Logging.On)
{
Logging.Exception(Logging.Web, "NetworkingPerfCounters", "Initialize", e);
}
Cleanup();
return;
}
finally
{
PerformanceCounterPermission.RevertAssert();
initDone = true;
if (Logging.On)
{
if (initSuccessful)
{
Logging.PrintInfo(Logging.Web, SR.GetString(SR.net_perfcounter_initialized_success));
}
else
{
Logging.PrintInfo(Logging.Web, SR.GetString(SR.net_perfcounter_initialized_error));
}
}
}
}