public static bool DoesAuthTypeMatch(AuthenticationSchemes authScheme, string authType)
        {
            if ((authType == null) || (authType.Length == 0))
            {
                return authScheme.IsSet(AuthenticationSchemes.Anonymous);
            }

            if (authType.Equals("kerberos", StringComparison.OrdinalIgnoreCase) ||
                authType.Equals("negotiate", StringComparison.OrdinalIgnoreCase))
            {
                return authScheme.IsSet(AuthenticationSchemes.Negotiate);
            }
            else if (authType.Equals("ntlm", StringComparison.OrdinalIgnoreCase))
            {
                return authScheme.IsSet(AuthenticationSchemes.Negotiate) ||
                    authScheme.IsSet(AuthenticationSchemes.Ntlm);
            }

            AuthenticationSchemes authTypeScheme;
            if (!Enum.TryParse<AuthenticationSchemes>(authType, true, out authTypeScheme))
            {
                return false;
            }

            return authScheme.IsSet(authTypeScheme);
        }

 internal static HttpClientCredentialType MapToClientCredentialType(AuthenticationSchemes authenticationSchemes)
 {
     HttpClientCredentialType result;
     switch (authenticationSchemes)
     {
         case AuthenticationSchemes.Anonymous:
             result = HttpClientCredentialType.None;
             break;
         case AuthenticationSchemes.Basic:
             result = HttpClientCredentialType.Basic;
             break;
         case AuthenticationSchemes.Digest:
             result = HttpClientCredentialType.Digest;
             break;
         case AuthenticationSchemes.Ntlm:
             result = HttpClientCredentialType.Ntlm;
             break;
         case AuthenticationSchemes.Negotiate:
             result = HttpClientCredentialType.Windows;
             break;
         default:
             Fx.Assert("unsupported client AuthenticationScheme");
             throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException());
     }
     return result;
 }

 public HttpListener(ILogger logger)
 {
     _logger = logger;
     prefixes = new HttpListenerPrefixCollection(logger, this);
     registry = new Hashtable();
     connections = Hashtable.Synchronized(new Hashtable());
     auth_schemes = AuthenticationSchemes.Anonymous;
 }

 ServiceAuthenticationBehavior(ServiceAuthenticationBehavior other)
 {
     this.serviceAuthenticationManager = other.ServiceAuthenticationManager;
     this.authenticationSchemes = other.authenticationSchemes;
     this.isReadOnly = other.isReadOnly;
     this.isAuthenticationManagerSet = other.isAuthenticationManagerSet;
     this.isAuthenticationSchemesSet = other.isAuthenticationSchemesSet;
 }

		public static HttpListener CreateAndStartListener (string prefix, AuthenticationSchemes authSchemes)
		{
			HttpListener listener = new HttpListener ();
			listener.AuthenticationSchemes = authSchemes;
			listener.Prefixes.Add (prefix);
			listener.Start ();
			return listener;
		}

 public static bool IsWindowsAuth(AuthenticationSchemes authScheme)
 {
     if (authScheme != AuthenticationSchemes.Negotiate)
     {
         return (authScheme == AuthenticationSchemes.Ntlm);
     }
     return true;
 }

		ArrayList wait_queue; // List<ListenerAsyncResult> wait_queue;

		public HttpListener ()
		{
			prefixes = new HttpListenerPrefixCollection (this);
			registry = new Hashtable ();
			ctx_queue = new ArrayList ();
			wait_queue = new ArrayList ();
			auth_schemes = AuthenticationSchemes.Anonymous;
		}

 /// <summary>
 /// Initializes a new instance of the <see cref="HttpListener"/> class.
 /// </summary>
 public HttpListener ()
 {
   _authSchemes = AuthenticationSchemes.Anonymous;
   _connections = new Dictionary<HttpConnection, HttpConnection> ();
   _contextQueue = new List<HttpListenerContext> ();
   _prefixes = new HttpListenerPrefixCollection (this);
   _registry = new Dictionary<HttpListenerContext, HttpListenerContext> ();
   _waitQueue = new List<ListenerAsyncResult> ();
 }

 internal HttpListenerContext(HttpListener httpListener, RequestContextBase memoryBlob)
 {
     if (Logging.On) Logging.PrintInfo(Logging.HttpListener, this, ".ctor", "httpListener#" + ValidationHelper.HashString(httpListener) + " requestBlob=" + ValidationHelper.HashString((IntPtr) memoryBlob.RequestBlob));
     m_Listener = httpListener;
     m_Request = new HttpListenerRequest(this, memoryBlob);
     m_AuthenticationSchemes = httpListener.AuthenticationSchemes;
     m_ExtendedProtectionPolicy = httpListener.ExtendedProtectionPolicy;
     GlobalLog.Print("HttpListenerContext#" + ValidationHelper.HashString(this) + "::.ctor() HttpListener#" + ValidationHelper.HashString(m_Listener) + " HttpListenerRequest#" + ValidationHelper.HashString(m_Request));
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="HttpListener"/> class.
 /// </summary>
 public HttpListener()
 {
     prefixes     = new HttpListenerPrefixCollection (this);
     registry     = new Dictionary<HttpListenerContext, HttpListenerContext> ();
     connections  = new Dictionary<HttpConnection, HttpConnection> ();
     ctx_queue    = new List<HttpListenerContext> ();
     wait_queue   = new List<ListenerAsyncResult> ();
     auth_schemes = AuthenticationSchemes.Anonymous;
 }

 internal AuthenticationChallenge(AuthenticationSchemes scheme, string realm)
     : base(scheme, new NameValueCollection ())
 {
     Parameters["realm"] = realm;
       if (scheme == AuthenticationSchemes.Digest) {
     Parameters["nonce"] = CreateNonceValue ();
     Parameters["algorithm"] = "MD5";
     Parameters["qop"] = "auth";
       }
 }

		public static WebhookServer Create(string url, Action<HttpListenerContext> handler, AuthenticationSchemes authenticationSchemes = AuthenticationSchemes.Anonymous)
		{
			var listener = new HttpListener
			{
				Prefixes = { url },
				AuthenticationSchemes = authenticationSchemes
			};
			var server = new WebhookServer(listener, handler);
			server.Start();
			return server;
		}

		public HttpListener ()
		{
			prefixes = new HttpListenerPrefixCollection (this);
			registry = new Hashtable ();
			connections = Hashtable.Synchronized (new Hashtable ());
			ctx_queue = new ArrayList ();
			wait_queue = new ArrayList ();
			auth_schemes = AuthenticationSchemes.Anonymous;
			defaultServiceNames = new ServiceNameStore ();
			extendedProtectionPolicy = new ExtendedProtectionPolicy (PolicyEnforcement.Never);
		}

        public RtspSource(string name, string sourceLocation, NetworkCredential credential = null, AuthenticationSchemes authType = AuthenticationSchemes.None, Rtsp.RtspClient.ClientProtocolType? rtpProtocolType = null, int bufferSize = RtspClient.DefaultBufferSize, Sdp.MediaType? specificMedia = null, TimeSpan? startTime = null, TimeSpan? endTime = null)
            : this(name, new Uri(sourceLocation), credential, authType, rtpProtocolType, bufferSize, specificMedia, startTime, endTime)
        {
            //Check for a null Credential and UserInfo in the Location given.
            if (credential == null && !string.IsNullOrWhiteSpace(m_Source.UserInfo))
            {
                RtspClient.Credential = Media.Common.Extensions.Uri.UriExtensions.ParseUserInfo(m_Source);

                //Remove the user info from the location
                RtspClient.CurrentLocation = new Uri(RtspClient.CurrentLocation.AbsoluteUri.Replace(RtspClient.CurrentLocation.UserInfo + (char)Common.ASCII.AtSign, string.Empty).Replace(RtspClient.CurrentLocation.UserInfo, string.Empty));
            }
        }

 public static bool TryExtract(BindingParameterCollection collection, out AuthenticationSchemes authenticationSchemes)
 {
     Fx.Assert(collection != null, "collection != null");
     authenticationSchemes = AuthenticationSchemes.None;
     AuthenticationSchemesBindingParameter instance = collection.Find<AuthenticationSchemesBindingParameter>();
     if (instance != null)
     {
         authenticationSchemes = instance.AuthenticationSchemes;
         return true;
     }
     return false;
 }

 public static bool DoesAuthTypeMatch(AuthenticationSchemes authScheme, string authType)
 {
     if ((authType == null) || (authType.Length == 0))
     {
         return (authScheme == AuthenticationSchemes.Anonymous);
     }
     if (authScheme == AuthenticationSchemes.Negotiate)
     {
         return ((authType.Equals("ntlm", StringComparison.OrdinalIgnoreCase) || authType.Equals("kerberos", StringComparison.OrdinalIgnoreCase)) || authType.Equals("negotiate", StringComparison.OrdinalIgnoreCase));
     }
     return authScheme.ToString().Equals(authType, StringComparison.OrdinalIgnoreCase);
 }

 public static bool IsSingleton(AuthenticationSchemes v)
 {
     switch (v)
     {
         case AuthenticationSchemes.Digest:
         case AuthenticationSchemes.Negotiate:
         case AuthenticationSchemes.Ntlm:
         case AuthenticationSchemes.Basic:
         case AuthenticationSchemes.Anonymous:
             return true;
     }
     return false;
 }

 internal AuthenticationResponse (
   AuthenticationSchemes scheme,
   NameValueCollection parameters,
   NetworkCredential credentials,
   uint nonceCount)
   : base (scheme, parameters)
 {
   Parameters["username"] = credentials.UserName;
   Parameters["password"] = credentials.Password;
   Parameters["uri"] = credentials.Domain;
   _nonceCount = nonceCount;
   if (scheme == AuthenticationSchemes.Digest)
     initAsDigest ();
 }

        public static Task<NetworkCredential> GetCredentialAsync(AuthenticationSchemes authenticationScheme, SecurityTokenProviderContainer credentialProvider,
            OutWrapper<TokenImpersonationLevel> impersonationLevelWrapper, OutWrapper<AuthenticationLevel> authenticationLevelWrapper,
            CancellationToken cancellationToken)
        {
            impersonationLevelWrapper.Value = TokenImpersonationLevel.None;
            authenticationLevelWrapper.Value = AuthenticationLevel.None;

            if (authenticationScheme == AuthenticationSchemes.Anonymous)
            {
                return Task.FromResult((NetworkCredential)null);
            }

            return GetCredentialCoreAsync(authenticationScheme, credentialProvider, impersonationLevelWrapper,
                    authenticationLevelWrapper, cancellationToken);
        }

		internal void ParseAuthentication (AuthenticationSchemes expectedSchemes) {
			if (expectedSchemes == AuthenticationSchemes.Anonymous)
				return;

			// TODO: Handle NTLM/Digest modes
			string header = request.Headers ["Authorization"];
			if (header == null || header.Length < 2)
				return;

			string [] authenticationData = header.Split (new char [] {' '}, 2);
			if (string.Compare (authenticationData [0], "basic", true) == 0) {
				user = ParseBasicAuthentication (authenticationData [1]);
			}
			// TODO: throw if malformed -> 400 bad request
		}