Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / Net / System / Net / CredentialCache.cs / 1305376 / CredentialCache.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
namespace System.Net {
using System.Net.Sockets;
using System.Collections;
using System.Runtime.InteropServices;
using System.Security.Permissions;
using System.Globalization;
// More sophisticated password cache that stores multiple
// name-password pairs and associates these with host/realm
///
/// Provides storage for multiple credentials.
///
public class CredentialCache : ICredentials, ICredentialsByHost, IEnumerable {
// fields
private Hashtable cache = new Hashtable();
private Hashtable cacheForHosts = new Hashtable();
internal int m_version;
private int m_NumbDefaultCredInCache = 0;
// [thread token optimization] The resulting counter of default credential resided in the cache.
internal bool IsDefaultInCache {
get {
return m_NumbDefaultCredInCache != 0;
}
}
// constructors
///
///
/// Initializes a new instance of the
///
public CredentialCache() {
}
// properties
// methods
///
/// Adds a
///
// UEUE
public void Add(Uri uriPrefix, string authType, NetworkCredential cred) {
//
// parameter validation
//
if (uriPrefix==null) {
throw new ArgumentNullException("uriPrefix");
}
if (authType==null) {
throw new ArgumentNullException("authType");
}
if ((cred is SystemNetworkCredential)
#if !FEATURE_PAL
&& !((string.Compare(authType, NtlmClient.AuthType, StringComparison.OrdinalIgnoreCase)==0)
|| (DigestClient.WDigestAvailable && (string.Compare(authType, DigestClient.AuthType, StringComparison.OrdinalIgnoreCase)==0))
|| (string.Compare(authType, KerberosClient.AuthType, StringComparison.OrdinalIgnoreCase)==0)
|| (string.Compare(authType, NegotiateClient.AuthType, StringComparison.OrdinalIgnoreCase)==0))
#endif
) {
throw new ArgumentException(SR.GetString(SR.net_nodefaultcreds, authType), "authType");
}
++m_version;
CredentialKey key = new CredentialKey(uriPrefix, authType);
GlobalLog.Print("CredentialCache::Add() Adding key:[" + key.ToString() + "], cred:[" + cred.Domain + "],[" + cred.UserName + "]");
cache.Add(key, cred);
if (cred is SystemNetworkCredential) {
++m_NumbDefaultCredInCache;
}
}
public void Add(string host, int port, string authenticationType, NetworkCredential credential) {
//
// parameter validation
//
if (host==null) {
throw new ArgumentNullException("host");
}
if (authenticationType==null) {
throw new ArgumentNullException("authenticationType");
}
if (host.Length == 0) {
throw new ArgumentException(SR.GetString(SR.net_emptystringcall,"host"));
}
if (port < 0) {
throw new ArgumentOutOfRangeException("port");
}
if ((credential is SystemNetworkCredential)
#if !FEATURE_PAL
&& !((string.Compare(authenticationType, NtlmClient.AuthType, StringComparison.OrdinalIgnoreCase)==0)
|| (DigestClient.WDigestAvailable && (string.Compare(authenticationType, DigestClient.AuthType, StringComparison.OrdinalIgnoreCase)==0))
|| (string.Compare(authenticationType, KerberosClient.AuthType, StringComparison.OrdinalIgnoreCase)==0)
|| (string.Compare(authenticationType, NegotiateClient.AuthType, StringComparison.OrdinalIgnoreCase)==0))
#endif
) {
throw new ArgumentException(SR.GetString(SR.net_nodefaultcreds, authenticationType), "authenticationType");
}
++m_version;
CredentialHostKey key = new CredentialHostKey(host,port, authenticationType);
GlobalLog.Print("CredentialCache::Add() Adding key:[" + key.ToString() + "], cred:[" + credential.Domain + "],[" + credential.UserName + "]");
cacheForHosts.Add(key, credential);
if (credential is SystemNetworkCredential) {
++m_NumbDefaultCredInCache;
}
}
///
/// Removes a
///
public void Remove(Uri uriPrefix, string authType) {
if (uriPrefix==null || authType==null) {
// these couldn't possibly have been inserted into
// the cache because of the test in Add()
return;
}
++m_version;
CredentialKey key = new CredentialKey(uriPrefix, authType);
GlobalLog.Print("CredentialCache::Remove() Removing key:[" + key.ToString() + "]");
if (cache[key] is SystemNetworkCredential) {
--m_NumbDefaultCredInCache;
}
cache.Remove(key);
}
public void Remove(string host, int port, string authenticationType) {
if (host==null || authenticationType==null) {
// these couldn't possibly have been inserted into
// the cache because of the test in Add()
return;
}
if (port < 0) {
return;
}
++m_version;
CredentialHostKey key = new CredentialHostKey(host, port, authenticationType);
GlobalLog.Print("CredentialCache::Remove() Removing key:[" + key.ToString() + "]");
if (cacheForHosts[key] is SystemNetworkCredential) {
--m_NumbDefaultCredInCache;
}
cacheForHosts.Remove(key);
}
///
///
/// Returns the
///
public NetworkCredential GetCredential(Uri uriPrefix, string authType) {
if (uriPrefix==null)
throw new ArgumentNullException("uriPrefix");
if (authType==null)
throw new ArgumentNullException("authType");
GlobalLog.Print("CredentialCache::GetCredential(uriPrefix=\"" + uriPrefix + "\", authType=\"" + authType + "\")");
int longestMatchPrefix = -1;
NetworkCredential mostSpecificMatch = null;
IDictionaryEnumerator credEnum = cache.GetEnumerator();
//
// Enumerate through every credential in the cache
//
while (credEnum.MoveNext()) {
CredentialKey key = (CredentialKey)credEnum.Key;
//
// Determine if this credential is applicable to the current Uri/AuthType
//
if (key.Match(uriPrefix, authType)) {
int prefixLen = key.UriPrefixLength;
//
// Check if the match is better than the current-most-specific match
//
if (prefixLen > longestMatchPrefix) {
//
// Yes-- update the information about currently preferred match
//
longestMatchPrefix = prefixLen;
mostSpecificMatch = (NetworkCredential)credEnum.Value;
}
}
}
GlobalLog.Print("CredentialCache::GetCredential returning " + ((mostSpecificMatch==null)?"null":"(" + mostSpecificMatch.UserName + ":" + mostSpecificMatch.Domain + ")"));
return mostSpecificMatch;
}
public NetworkCredential GetCredential(string host, int port, string authenticationType) {
if (host==null) {
throw new ArgumentNullException("host");
}
if (authenticationType==null){
throw new ArgumentNullException("authenticationType");
}
if (host.Length == 0) {
throw new ArgumentException(SR.GetString(SR.net_emptystringcall, "host"));
}
if (port < 0) {
throw new ArgumentOutOfRangeException("port");
}
GlobalLog.Print("CredentialCache::GetCredential(host=\"" + host + ":" + port.ToString() +"\", authenticationType=\"" + authenticationType + "\")");
NetworkCredential match = null;
IDictionaryEnumerator credEnum = cacheForHosts.GetEnumerator();
//
// Enumerate through every credential in the cache
//
while (credEnum.MoveNext()) {
CredentialHostKey key = (CredentialHostKey)credEnum.Key;
//
// Determine if this credential is applicable to the current Uri/AuthType
//
if (key.Match(host, port, authenticationType)) {
match = (NetworkCredential)credEnum.Value;
}
}
GlobalLog.Print("CredentialCache::GetCredential returning " + ((match==null)?"null":"(" + match.UserName + ":" + match.Domain + ")"));
return match;
}
///
/// [To be supplied]
///
//
// IEnumerable interface
//
public IEnumerator GetEnumerator() {
return new CredentialEnumerator(this, cache ,cacheForHosts, m_version);
}
///
///
/// Gets
/// the default system credentials from the
///
public static ICredentials DefaultCredentials {
get {
//This check will not allow to use local user credentials at will.
//Hence the username will not be exposed to the network
new EnvironmentPermission(EnvironmentPermissionAccess.Read, "USERNAME").Demand();
return SystemNetworkCredential.defaultCredential;
}
}
public static NetworkCredential DefaultNetworkCredentials {
get {
//This check will not allow to use local user credentials at will.
//Hence the username will not be exposed to the network
new EnvironmentPermission(EnvironmentPermissionAccess.Read, "USERNAME").Demand();
return SystemNetworkCredential.defaultCredential;
}
}
private class CredentialEnumerator : IEnumerator {
// fields
private CredentialCache m_cache;
private ICredentials[] m_array;
private int m_index = -1;
private int m_version;
// constructors
internal CredentialEnumerator(CredentialCache cache, Hashtable table, Hashtable hostTable, int version) {
m_cache = cache;
m_array = new ICredentials[table.Count + hostTable.Count];
table.Values.CopyTo(m_array, 0);
hostTable.Values.CopyTo(m_array, table.Count);
m_version = version;
}
// IEnumerator interface
// properties
object IEnumerator.Current {
get {
if (m_index < 0 || m_index >= m_array.Length) {
throw new InvalidOperationException(SR.GetString(SR.InvalidOperation_EnumOpCantHappen));
}
if (m_version != m_cache.m_version) {
throw new InvalidOperationException(SR.GetString(SR.InvalidOperation_EnumFailedVersion));
}
return m_array[m_index];
}
}
// methods
bool IEnumerator.MoveNext() {
if (m_version != m_cache.m_version) {
throw new InvalidOperationException(SR.GetString(SR.InvalidOperation_EnumFailedVersion));
}
if (++m_index < m_array.Length) {
return true;
}
m_index = m_array.Length;
return false;
}
void IEnumerator.Reset() {
m_index = -1;
}
} // class CredentialEnumerator
} // class CredentialCache
// Abstraction for credentials in password-based
// authentication schemes (basic, digest, NTLM, Kerberos)
// Note this is not applicable to public-key based
// systems such as SSL client authentication
// "Password" here may be the clear text password or it
// could be a one-way hash that is sufficient to
// authenticate, as in HTTP/1.1 digest.
//
// Object representing default credentials
//
internal class SystemNetworkCredential : NetworkCredential {
internal static readonly SystemNetworkCredential defaultCredential = new SystemNetworkCredential();
// We want reference equality to work. Making this private is a good way to guarantee that.
private SystemNetworkCredential() :
base(string.Empty, string.Empty, string.Empty) {
}
}
internal class CredentialHostKey {
internal string Host;
internal string AuthenticationType;
internal int Port;
internal CredentialHostKey(string host, int port, string authenticationType) {
Host = host;
Port = port;
AuthenticationType = authenticationType;
}
internal bool Match(string host, int port, string authenticationType) {
if (host==null || authenticationType==null) {
return false;
}
//
// If the protocols dont match this credential
// is not applicable for the given Uri
//
if (string.Compare(authenticationType, AuthenticationType, StringComparison.OrdinalIgnoreCase) != 0) {
return false;
}
if (string.Compare(Host, host, StringComparison.OrdinalIgnoreCase ) != 0) {
return false;
}
if (port != Port) {
return false;
}
GlobalLog.Print("CredentialKey::Match(" + Host.ToString() + ":" + Port.ToString() +" & " + host.ToString() + ":" + port.ToString() + ")");
return true;
}
private int m_HashCode = 0;
private bool m_ComputedHashCode = false;
public override int GetHashCode() {
if (!m_ComputedHashCode) {
//
// compute HashCode on demand
//
m_HashCode = AuthenticationType.ToUpperInvariant().GetHashCode() + Host.ToUpperInvariant().GetHashCode() + Port.GetHashCode();
m_ComputedHashCode = true;
}
return m_HashCode;
}
public override bool Equals(object comparand) {
CredentialHostKey comparedCredentialKey = comparand as CredentialHostKey;
if (comparand==null) {
//
// this covers also the compared==null case
//
return false;
}
bool equals =
(string.Compare(AuthenticationType, comparedCredentialKey.AuthenticationType, StringComparison.OrdinalIgnoreCase ) == 0) &&
(string.Compare(Host, comparedCredentialKey.Host, StringComparison.OrdinalIgnoreCase ) == 0) &&
Port == comparedCredentialKey.Port;
GlobalLog.Print("CredentialKey::Equals(" + ToString() + ", " + comparedCredentialKey.ToString() + ") returns " + equals.ToString());
return equals;
}
public override string ToString() {
return "[" + Host.Length.ToString(NumberFormatInfo.InvariantInfo) + "]:" + Host + ":" + Port.ToString(NumberFormatInfo.InvariantInfo) + ":" + ValidationHelper.ToString(AuthenticationType);
}
} // class CredentialKey
internal class CredentialKey {
internal Uri UriPrefix;
internal int UriPrefixLength = -1;
internal string AuthenticationType;
internal CredentialKey(Uri uriPrefix, string authenticationType) {
UriPrefix = uriPrefix;
UriPrefixLength = UriPrefix.ToString().Length;
AuthenticationType = authenticationType;
}
internal bool Match(Uri uri, string authenticationType) {
if (uri==null || authenticationType==null) {
return false;
}
//
// If the protocols dont match this credential
// is not applicable for the given Uri
//
if (string.Compare(authenticationType, AuthenticationType, StringComparison.OrdinalIgnoreCase) != 0) {
return false;
}
GlobalLog.Print("CredentialKey::Match(" + UriPrefix.ToString() + " & " + uri.ToString() + ")");
return IsPrefix(uri, UriPrefix);
}
//
// IsPrefix (Uri)
//
// Determines whether is a prefix of this URI. A prefix
// match is defined as:
//
// scheme match
// + host match
// + port match, if any
// + path is a prefix of path, if any
//
// Returns:
// True if is a prefix of this URI
//
internal bool IsPrefix(Uri uri, Uri prefixUri) {
if (prefixUri.Scheme != uri.Scheme || prefixUri.Host != uri.Host || prefixUri.Port != uri.Port)
return false;
int prefixLen = prefixUri.AbsolutePath.LastIndexOf('/');
if (prefixLen > uri.AbsolutePath.LastIndexOf('/'))
return false;
return String.Compare(uri.AbsolutePath, 0, prefixUri.AbsolutePath, 0, prefixLen, StringComparison.OrdinalIgnoreCase ) == 0;
}
private int m_HashCode = 0;
private bool m_ComputedHashCode = false;
public override int GetHashCode() {
if (!m_ComputedHashCode) {
//
// compute HashCode on demand
//
m_HashCode = AuthenticationType.ToUpperInvariant().GetHashCode() + UriPrefixLength + UriPrefix.GetHashCode();
m_ComputedHashCode = true;
}
return m_HashCode;
}
public override bool Equals(object comparand) {
CredentialKey comparedCredentialKey = comparand as CredentialKey;
if (comparand==null) {
//
// this covers also the compared==null case
//
return false;
}
bool equals =
(string.Compare(AuthenticationType, comparedCredentialKey.AuthenticationType, StringComparison.OrdinalIgnoreCase ) == 0) &&
UriPrefix.Equals(comparedCredentialKey.UriPrefix);
GlobalLog.Print("CredentialKey::Equals(" + ToString() + ", " + comparedCredentialKey.ToString() + ") returns " + equals.ToString());
return equals;
}
public override string ToString() {
return "[" + UriPrefixLength.ToString(NumberFormatInfo.InvariantInfo) + "]:" + ValidationHelper.ToString(UriPrefix) + ":" + ValidationHelper.ToString(AuthenticationType);
}
} // class CredentialKey
} // namespace System.Net
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
namespace System.Net {
using System.Net.Sockets;
using System.Collections;
using System.Runtime.InteropServices;
using System.Security.Permissions;
using System.Globalization;
// More sophisticated password cache that stores multiple
// name-password pairs and associates these with host/realm
///
/// Provides storage for multiple credentials.
///
public class CredentialCache : ICredentials, ICredentialsByHost, IEnumerable {
// fields
private Hashtable cache = new Hashtable();
private Hashtable cacheForHosts = new Hashtable();
internal int m_version;
private int m_NumbDefaultCredInCache = 0;
// [thread token optimization] The resulting counter of default credential resided in the cache.
internal bool IsDefaultInCache {
get {
return m_NumbDefaultCredInCache != 0;
}
}
// constructors
///
///
/// Initializes a new instance of the
///
public CredentialCache() {
}
// properties
// methods
///
/// Adds a
///
// UEUE
public void Add(Uri uriPrefix, string authType, NetworkCredential cred) {
//
// parameter validation
//
if (uriPrefix==null) {
throw new ArgumentNullException("uriPrefix");
}
if (authType==null) {
throw new ArgumentNullException("authType");
}
if ((cred is SystemNetworkCredential)
#if !FEATURE_PAL
&& !((string.Compare(authType, NtlmClient.AuthType, StringComparison.OrdinalIgnoreCase)==0)
|| (DigestClient.WDigestAvailable && (string.Compare(authType, DigestClient.AuthType, StringComparison.OrdinalIgnoreCase)==0))
|| (string.Compare(authType, KerberosClient.AuthType, StringComparison.OrdinalIgnoreCase)==0)
|| (string.Compare(authType, NegotiateClient.AuthType, StringComparison.OrdinalIgnoreCase)==0))
#endif
) {
throw new ArgumentException(SR.GetString(SR.net_nodefaultcreds, authType), "authType");
}
++m_version;
CredentialKey key = new CredentialKey(uriPrefix, authType);
GlobalLog.Print("CredentialCache::Add() Adding key:[" + key.ToString() + "], cred:[" + cred.Domain + "],[" + cred.UserName + "]");
cache.Add(key, cred);
if (cred is SystemNetworkCredential) {
++m_NumbDefaultCredInCache;
}
}
public void Add(string host, int port, string authenticationType, NetworkCredential credential) {
//
// parameter validation
//
if (host==null) {
throw new ArgumentNullException("host");
}
if (authenticationType==null) {
throw new ArgumentNullException("authenticationType");
}
if (host.Length == 0) {
throw new ArgumentException(SR.GetString(SR.net_emptystringcall,"host"));
}
if (port < 0) {
throw new ArgumentOutOfRangeException("port");
}
if ((credential is SystemNetworkCredential)
#if !FEATURE_PAL
&& !((string.Compare(authenticationType, NtlmClient.AuthType, StringComparison.OrdinalIgnoreCase)==0)
|| (DigestClient.WDigestAvailable && (string.Compare(authenticationType, DigestClient.AuthType, StringComparison.OrdinalIgnoreCase)==0))
|| (string.Compare(authenticationType, KerberosClient.AuthType, StringComparison.OrdinalIgnoreCase)==0)
|| (string.Compare(authenticationType, NegotiateClient.AuthType, StringComparison.OrdinalIgnoreCase)==0))
#endif
) {
throw new ArgumentException(SR.GetString(SR.net_nodefaultcreds, authenticationType), "authenticationType");
}
++m_version;
CredentialHostKey key = new CredentialHostKey(host,port, authenticationType);
GlobalLog.Print("CredentialCache::Add() Adding key:[" + key.ToString() + "], cred:[" + credential.Domain + "],[" + credential.UserName + "]");
cacheForHosts.Add(key, credential);
if (credential is SystemNetworkCredential) {
++m_NumbDefaultCredInCache;
}
}
///
/// Removes a
///
public void Remove(Uri uriPrefix, string authType) {
if (uriPrefix==null || authType==null) {
// these couldn't possibly have been inserted into
// the cache because of the test in Add()
return;
}
++m_version;
CredentialKey key = new CredentialKey(uriPrefix, authType);
GlobalLog.Print("CredentialCache::Remove() Removing key:[" + key.ToString() + "]");
if (cache[key] is SystemNetworkCredential) {
--m_NumbDefaultCredInCache;
}
cache.Remove(key);
}
public void Remove(string host, int port, string authenticationType) {
if (host==null || authenticationType==null) {
// these couldn't possibly have been inserted into
// the cache because of the test in Add()
return;
}
if (port < 0) {
return;
}
++m_version;
CredentialHostKey key = new CredentialHostKey(host, port, authenticationType);
GlobalLog.Print("CredentialCache::Remove() Removing key:[" + key.ToString() + "]");
if (cacheForHosts[key] is SystemNetworkCredential) {
--m_NumbDefaultCredInCache;
}
cacheForHosts.Remove(key);
}
///
///
/// Returns the
///
public NetworkCredential GetCredential(Uri uriPrefix, string authType) {
if (uriPrefix==null)
throw new ArgumentNullException("uriPrefix");
if (authType==null)
throw new ArgumentNullException("authType");
GlobalLog.Print("CredentialCache::GetCredential(uriPrefix=\"" + uriPrefix + "\", authType=\"" + authType + "\")");
int longestMatchPrefix = -1;
NetworkCredential mostSpecificMatch = null;
IDictionaryEnumerator credEnum = cache.GetEnumerator();
//
// Enumerate through every credential in the cache
//
while (credEnum.MoveNext()) {
CredentialKey key = (CredentialKey)credEnum.Key;
//
// Determine if this credential is applicable to the current Uri/AuthType
//
if (key.Match(uriPrefix, authType)) {
int prefixLen = key.UriPrefixLength;
//
// Check if the match is better than the current-most-specific match
//
if (prefixLen > longestMatchPrefix) {
//
// Yes-- update the information about currently preferred match
//
longestMatchPrefix = prefixLen;
mostSpecificMatch = (NetworkCredential)credEnum.Value;
}
}
}
GlobalLog.Print("CredentialCache::GetCredential returning " + ((mostSpecificMatch==null)?"null":"(" + mostSpecificMatch.UserName + ":" + mostSpecificMatch.Domain + ")"));
return mostSpecificMatch;
}
public NetworkCredential GetCredential(string host, int port, string authenticationType) {
if (host==null) {
throw new ArgumentNullException("host");
}
if (authenticationType==null){
throw new ArgumentNullException("authenticationType");
}
if (host.Length == 0) {
throw new ArgumentException(SR.GetString(SR.net_emptystringcall, "host"));
}
if (port < 0) {
throw new ArgumentOutOfRangeException("port");
}
GlobalLog.Print("CredentialCache::GetCredential(host=\"" + host + ":" + port.ToString() +"\", authenticationType=\"" + authenticationType + "\")");
NetworkCredential match = null;
IDictionaryEnumerator credEnum = cacheForHosts.GetEnumerator();
//
// Enumerate through every credential in the cache
//
while (credEnum.MoveNext()) {
CredentialHostKey key = (CredentialHostKey)credEnum.Key;
//
// Determine if this credential is applicable to the current Uri/AuthType
//
if (key.Match(host, port, authenticationType)) {
match = (NetworkCredential)credEnum.Value;
}
}
GlobalLog.Print("CredentialCache::GetCredential returning " + ((match==null)?"null":"(" + match.UserName + ":" + match.Domain + ")"));
return match;
}
///
/// [To be supplied]
///
//
// IEnumerable interface
//
public IEnumerator GetEnumerator() {
return new CredentialEnumerator(this, cache ,cacheForHosts, m_version);
}
///
///
/// Gets
/// the default system credentials from the
///
public static ICredentials DefaultCredentials {
get {
//This check will not allow to use local user credentials at will.
//Hence the username will not be exposed to the network
new EnvironmentPermission(EnvironmentPermissionAccess.Read, "USERNAME").Demand();
return SystemNetworkCredential.defaultCredential;
}
}
public static NetworkCredential DefaultNetworkCredentials {
get {
//This check will not allow to use local user credentials at will.
//Hence the username will not be exposed to the network
new EnvironmentPermission(EnvironmentPermissionAccess.Read, "USERNAME").Demand();
return SystemNetworkCredential.defaultCredential;
}
}
private class CredentialEnumerator : IEnumerator {
// fields
private CredentialCache m_cache;
private ICredentials[] m_array;
private int m_index = -1;
private int m_version;
// constructors
internal CredentialEnumerator(CredentialCache cache, Hashtable table, Hashtable hostTable, int version) {
m_cache = cache;
m_array = new ICredentials[table.Count + hostTable.Count];
table.Values.CopyTo(m_array, 0);
hostTable.Values.CopyTo(m_array, table.Count);
m_version = version;
}
// IEnumerator interface
// properties
object IEnumerator.Current {
get {
if (m_index < 0 || m_index >= m_array.Length) {
throw new InvalidOperationException(SR.GetString(SR.InvalidOperation_EnumOpCantHappen));
}
if (m_version != m_cache.m_version) {
throw new InvalidOperationException(SR.GetString(SR.InvalidOperation_EnumFailedVersion));
}
return m_array[m_index];
}
}
// methods
bool IEnumerator.MoveNext() {
if (m_version != m_cache.m_version) {
throw new InvalidOperationException(SR.GetString(SR.InvalidOperation_EnumFailedVersion));
}
if (++m_index < m_array.Length) {
return true;
}
m_index = m_array.Length;
return false;
}
void IEnumerator.Reset() {
m_index = -1;
}
} // class CredentialEnumerator
} // class CredentialCache
// Abstraction for credentials in password-based
// authentication schemes (basic, digest, NTLM, Kerberos)
// Note this is not applicable to public-key based
// systems such as SSL client authentication
// "Password" here may be the clear text password or it
// could be a one-way hash that is sufficient to
// authenticate, as in HTTP/1.1 digest.
//
// Object representing default credentials
//
internal class SystemNetworkCredential : NetworkCredential {
internal static readonly SystemNetworkCredential defaultCredential = new SystemNetworkCredential();
// We want reference equality to work. Making this private is a good way to guarantee that.
private SystemNetworkCredential() :
base(string.Empty, string.Empty, string.Empty) {
}
}
internal class CredentialHostKey {
internal string Host;
internal string AuthenticationType;
internal int Port;
internal CredentialHostKey(string host, int port, string authenticationType) {
Host = host;
Port = port;
AuthenticationType = authenticationType;
}
internal bool Match(string host, int port, string authenticationType) {
if (host==null || authenticationType==null) {
return false;
}
//
// If the protocols dont match this credential
// is not applicable for the given Uri
//
if (string.Compare(authenticationType, AuthenticationType, StringComparison.OrdinalIgnoreCase) != 0) {
return false;
}
if (string.Compare(Host, host, StringComparison.OrdinalIgnoreCase ) != 0) {
return false;
}
if (port != Port) {
return false;
}
GlobalLog.Print("CredentialKey::Match(" + Host.ToString() + ":" + Port.ToString() +" & " + host.ToString() + ":" + port.ToString() + ")");
return true;
}
private int m_HashCode = 0;
private bool m_ComputedHashCode = false;
public override int GetHashCode() {
if (!m_ComputedHashCode) {
//
// compute HashCode on demand
//
m_HashCode = AuthenticationType.ToUpperInvariant().GetHashCode() + Host.ToUpperInvariant().GetHashCode() + Port.GetHashCode();
m_ComputedHashCode = true;
}
return m_HashCode;
}
public override bool Equals(object comparand) {
CredentialHostKey comparedCredentialKey = comparand as CredentialHostKey;
if (comparand==null) {
//
// this covers also the compared==null case
//
return false;
}
bool equals =
(string.Compare(AuthenticationType, comparedCredentialKey.AuthenticationType, StringComparison.OrdinalIgnoreCase ) == 0) &&
(string.Compare(Host, comparedCredentialKey.Host, StringComparison.OrdinalIgnoreCase ) == 0) &&
Port == comparedCredentialKey.Port;
GlobalLog.Print("CredentialKey::Equals(" + ToString() + ", " + comparedCredentialKey.ToString() + ") returns " + equals.ToString());
return equals;
}
public override string ToString() {
return "[" + Host.Length.ToString(NumberFormatInfo.InvariantInfo) + "]:" + Host + ":" + Port.ToString(NumberFormatInfo.InvariantInfo) + ":" + ValidationHelper.ToString(AuthenticationType);
}
} // class CredentialKey
internal class CredentialKey {
internal Uri UriPrefix;
internal int UriPrefixLength = -1;
internal string AuthenticationType;
internal CredentialKey(Uri uriPrefix, string authenticationType) {
UriPrefix = uriPrefix;
UriPrefixLength = UriPrefix.ToString().Length;
AuthenticationType = authenticationType;
}
internal bool Match(Uri uri, string authenticationType) {
if (uri==null || authenticationType==null) {
return false;
}
//
// If the protocols dont match this credential
// is not applicable for the given Uri
//
if (string.Compare(authenticationType, AuthenticationType, StringComparison.OrdinalIgnoreCase) != 0) {
return false;
}
GlobalLog.Print("CredentialKey::Match(" + UriPrefix.ToString() + " & " + uri.ToString() + ")");
return IsPrefix(uri, UriPrefix);
}
//
// IsPrefix (Uri)
//
// Determines whether is a prefix of this URI. A prefix
// match is defined as:
//
// scheme match
// + host match
// + port match, if any
// + path is a prefix of path, if any
//
// Returns:
// True if is a prefix of this URI
//
internal bool IsPrefix(Uri uri, Uri prefixUri) {
if (prefixUri.Scheme != uri.Scheme || prefixUri.Host != uri.Host || prefixUri.Port != uri.Port)
return false;
int prefixLen = prefixUri.AbsolutePath.LastIndexOf('/');
if (prefixLen > uri.AbsolutePath.LastIndexOf('/'))
return false;
return String.Compare(uri.AbsolutePath, 0, prefixUri.AbsolutePath, 0, prefixLen, StringComparison.OrdinalIgnoreCase ) == 0;
}
private int m_HashCode = 0;
private bool m_ComputedHashCode = false;
public override int GetHashCode() {
if (!m_ComputedHashCode) {
//
// compute HashCode on demand
//
m_HashCode = AuthenticationType.ToUpperInvariant().GetHashCode() + UriPrefixLength + UriPrefix.GetHashCode();
m_ComputedHashCode = true;
}
return m_HashCode;
}
public override bool Equals(object comparand) {
CredentialKey comparedCredentialKey = comparand as CredentialKey;
if (comparand==null) {
//
// this covers also the compared==null case
//
return false;
}
bool equals =
(string.Compare(AuthenticationType, comparedCredentialKey.AuthenticationType, StringComparison.OrdinalIgnoreCase ) == 0) &&
UriPrefix.Equals(comparedCredentialKey.UriPrefix);
GlobalLog.Print("CredentialKey::Equals(" + ToString() + ", " + comparedCredentialKey.ToString() + ") returns " + equals.ToString());
return equals;
}
public override string ToString() {
return "[" + UriPrefixLength.ToString(NumberFormatInfo.InvariantInfo) + "]:" + ValidationHelper.ToString(UriPrefix) + ":" + ValidationHelper.ToString(AuthenticationType);
}
} // class CredentialKey
} // namespace System.Net
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- DESCryptoServiceProvider.cs
- BindingCompleteEventArgs.cs
- ItemType.cs
- ProfileGroupSettingsCollection.cs
- PerformanceCounter.cs
- StaticSiteMapProvider.cs
- WebGetAttribute.cs
- AutoScrollExpandMessageFilter.cs
- PauseStoryboard.cs
- HtmlContainerControl.cs
- Rijndael.cs
- DirectionalLight.cs
- XmlSchemaDocumentation.cs
- PageStatePersister.cs
- EventHandlerList.cs
- PermissionSet.cs
- XpsInterleavingPolicy.cs
- BooleanAnimationUsingKeyFrames.cs
- NotSupportedException.cs
- BitmapEffectCollection.cs
- ISessionStateStore.cs
- XpsSerializationManagerAsync.cs
- SimpleHandlerBuildProvider.cs
- DBConnectionString.cs
- TargetInvocationException.cs
- RequestCacheManager.cs
- TableLayoutSettings.cs
- HijriCalendar.cs
- DataGridViewEditingControlShowingEventArgs.cs
- MetadataItem_Static.cs
- DeclarativeCatalogPart.cs
- SHA1CryptoServiceProvider.cs
- OpacityConverter.cs
- ActivationServices.cs
- ClientRoleProvider.cs
- FillBehavior.cs
- DataRelationPropertyDescriptor.cs
- WindowsTokenRoleProvider.cs
- BasicExpressionVisitor.cs
- ToolStripItemTextRenderEventArgs.cs
- MimePart.cs
- QilFunction.cs
- CheckedListBox.cs
- ECDiffieHellmanCngPublicKey.cs
- COM2Enum.cs
- WriteTimeStream.cs
- Expression.DebuggerProxy.cs
- AtomServiceDocumentSerializer.cs
- XmlWriter.cs
- COM2Enum.cs
- ConnectionPointCookie.cs
- DateTimeConverter.cs
- RegexRunner.cs
- TextTreeTextElementNode.cs
- DataGridPagerStyle.cs
- DispatcherTimer.cs
- tibetanshape.cs
- COM2EnumConverter.cs
- XmlILStorageConverter.cs
- StateBag.cs
- BitmapFrameDecode.cs
- SqlClientPermission.cs
- XamlSerializer.cs
- RelatedView.cs
- FixedSOMGroup.cs
- BinaryObjectReader.cs
- BounceEase.cs
- StrokeFIndices.cs
- DelayDesigner.cs
- DropSource.cs
- HttpApplicationFactory.cs
- SchemaContext.cs
- ReadOnlyCollectionBuilder.cs
- SymbolPair.cs
- CompiledRegexRunner.cs
- followingsibling.cs
- DbConnectionPoolIdentity.cs
- x509utils.cs
- SqlClientMetaDataCollectionNames.cs
- BoundingRectTracker.cs
- CustomTypeDescriptor.cs
- AccessedThroughPropertyAttribute.cs
- SiteMapHierarchicalDataSourceView.cs
- DesignerTransaction.cs
- JournalEntryListConverter.cs
- TransformerTypeCollection.cs
- LineInfo.cs
- IntegrationExceptionEventArgs.cs
- XmlAnyAttributeAttribute.cs
- GridViewSelectEventArgs.cs
- Margins.cs
- XslAstAnalyzer.cs
- UIAgentMonitor.cs
- ToolStripPanelRow.cs
- DataGridColumnDropSeparator.cs
- Stack.cs
- WorkflowPersistenceContext.cs
- QilLoop.cs
- DefaultValueTypeConverter.cs
- XmlWrappingReader.cs