Code:
/ Net / Net / 3.5.50727.3053 / DEVDIV / depot / DevDiv / releases / whidbey / netfxsp / ndp / fx / src / Net / System / Net / CredentialCache.cs / 1 / 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
- DataContract.cs
- TimeoutException.cs
- MobileUserControl.cs
- UshortList2.cs
- AuthorizationSection.cs
- ConfigurationException.cs
- WebPartDesigner.cs
- CookielessHelper.cs
- Grid.cs
- CollectionViewProxy.cs
- XpsFixedDocumentReaderWriter.cs
- CaseKeyBox.xaml.cs
- GridViewColumnCollectionChangedEventArgs.cs
- PeerNameRecordCollection.cs
- MediaSystem.cs
- IOThreadTimer.cs
- AppliedDeviceFiltersEditor.cs
- TargetInvocationException.cs
- ExpandCollapsePattern.cs
- CodePrimitiveExpression.cs
- XsdBuilder.cs
- ConnectivityStatus.cs
- cookie.cs
- MediaSystem.cs
- MemoryPressure.cs
- FrameworkContextData.cs
- SHA1Managed.cs
- AsyncWaitHandle.cs
- DataFieldCollectionEditor.cs
- GeneralTransform.cs
- CodeArgumentReferenceExpression.cs
- FamilyTypeface.cs
- ScriptManager.cs
- XmlConvert.cs
- SchemaElementLookUpTable.cs
- TransactionInterop.cs
- XmlCharacterData.cs
- WebChannelFactory.cs
- SoapDocumentMethodAttribute.cs
- ActivityCollectionMarkupSerializer.cs
- NativeCppClassAttribute.cs
- FormsAuthenticationUserCollection.cs
- CacheOutputQuery.cs
- BinaryObjectReader.cs
- ShapingWorkspace.cs
- OleDbTransaction.cs
- ApplicationProxyInternal.cs
- WindowsListViewGroupHelper.cs
- AccessedThroughPropertyAttribute.cs
- Label.cs
- LinkArea.cs
- Model3D.cs
- Wildcard.cs
- DataGridViewDesigner.cs
- NameValueCache.cs
- AncestorChangedEventArgs.cs
- RuleSetDialog.cs
- WindowsProgressbar.cs
- ChunkedMemoryStream.cs
- NodeLabelEditEvent.cs
- TextTreeDeleteContentUndoUnit.cs
- RotationValidation.cs
- WsatServiceAddress.cs
- CssStyleCollection.cs
- TransformPatternIdentifiers.cs
- _FixedSizeReader.cs
- UInt64.cs
- ObjectDataSourceDesigner.cs
- Deflater.cs
- TrackingProfileCache.cs
- ToolStripProgressBar.cs
- ErrorHandlerModule.cs
- FilteredSchemaElementLookUpTable.cs
- CellTreeNodeVisitors.cs
- ConnectionDemuxer.cs
- BamlRecords.cs
- FactoryGenerator.cs
- ProcessProtocolHandler.cs
- WindowsListViewScroll.cs
- PermissionSet.cs
- Addressing.cs
- ListParaClient.cs
- Int32CollectionValueSerializer.cs
- ChannelSinkStacks.cs
- DesignTimeType.cs
- DataPointer.cs
- CodeBlockBuilder.cs
- XmlWriterDelegator.cs
- WindowsEditBoxRange.cs
- DocumentXPathNavigator.cs
- ExtendedPropertyDescriptor.cs
- ViewLoader.cs
- InstalledVoice.cs
- ApplicationFileCodeDomTreeGenerator.cs
- KnownIds.cs
- TemplateXamlParser.cs
- SectionInput.cs
- TrustLevelCollection.cs
- ReflectionUtil.cs
- SingleSelectRootGridEntry.cs