public override ChannelBinding GetChannelBinding(ChannelBindingKind kind)
        {
            if (kind != ChannelBindingKind.Endpoint)
                return null;

            return binding;
        }

 public override ChannelBinding GetChannelBinding(ChannelBindingKind kind)
 {
     if (kind != ChannelBindingKind.Endpoint)
     {
         throw new NotSupportedException(SR.GetString("net_listener_invalid_cbt_type", new object[] { kind.ToString() }));
     }
     return this.request.GetChannelBinding();
 }

 public override ChannelBinding GetChannelBinding(ChannelBindingKind kind)
 {
     if (kind != ChannelBindingKind.Endpoint)
     {
         return null;
     }
     return this.binding;
 }

 public override ChannelBinding GetChannelBinding(ChannelBindingKind kind)
 {
     if (kind != ChannelBindingKind.Endpoint)
     {
         throw new NotSupportedException(SR.Format(
             SR.net_listener_invalid_cbt_type, kind.ToString()));
     }
     return _request.GetChannelBinding();
 }

        public override ChannelBinding GetChannelBinding(ChannelBindingKind kind)
        {
            // WinHTTP only supports retrieval of ChannelBindingKind.Endpoint for CBT.
            if (kind == ChannelBindingKind.Endpoint)
            {
                return _channelBinding;
            }

            return null;
        }

        internal static SafeChannelBindingHandle QueryChannelBinding(SafeSslHandle context, ChannelBindingKind bindingType)
        {
            SafeChannelBindingHandle bindingHandle;
            switch (bindingType)
            {
                case ChannelBindingKind.Endpoint:
                    bindingHandle = new SafeChannelBindingHandle(bindingType);
                    QueryEndPointChannelBinding(context, bindingHandle);
                    break;

                case ChannelBindingKind.Unique:
                    bindingHandle = new SafeChannelBindingHandle(bindingType);
                    QueryUniqueChannelBinding(context, bindingHandle);
                    break;

                default:
                    // Keeping parity with windows, we should return null in this case.
                    bindingHandle = null;
                    break;
            }

            return bindingHandle;
        }

        public unsafe int QueryContextChannelBinding(SafeDeleteContext phContext, ChannelBindingKind attribute, out SafeFreeContextBufferChannelBinding refHandle)
        {
            refHandle = SafeFreeContextBufferChannelBinding.CreateEmptyHandle();

            // Bindings is on the stack, so there's no need for a fixed block.
            Bindings bindings = new Bindings();
            int errorCode = SafeFreeContextBufferChannelBinding.QueryContextChannelBinding(phContext, (Interop.Secur32.ContextAttribute)attribute, &bindings, refHandle);

            if (errorCode != 0)
            {
                GlobalLog.Leave("QueryContextChannelBinding", "ERROR = " + ErrorDescription(errorCode));
                refHandle = null;
            }

            return errorCode;
        }

 internal ChannelBinding GetChannelBinding(ChannelBindingKind kind)
 {
     ChannelBinding binding = null;
     if (this.m_SecurityContext != null)
     {
         binding = SSPIWrapper.QueryContextChannelBinding(GlobalSSPI.SSPISecureChannel, this.m_SecurityContext, (ContextAttribute) kind);
     }
     return binding;
 }

        internal ChannelBinding GetChannelBinding(ChannelBindingKind kind)
        {
            if (NetEventSource.IsEnabled) NetEventSource.Enter(this, kind);

            ChannelBinding result = null;
            if (_securityContext != null)
            {
                result = SslStreamPal.QueryContextChannelBinding(_securityContext, kind);
            }

            if (NetEventSource.IsEnabled) NetEventSource.Exit(this, result);
            return result;
        }

 internal ChannelBinding GetChannelBinding(ChannelBindingKind kind)
 {
     return null;
 }

 public unsafe static SafeFreeContextBufferChannelBinding QueryContextChannelBinding(SafeDeleteContext securityContext, ChannelBindingKind attribute)
 {
     return SSPIWrapper.QueryContextChannelBinding(GlobalSSPI.SSPISecureChannel, securityContext, (Interop.SspiCli.ContextAttribute)attribute);
 }

        internal static SafeFreeContextBufferChannelBinding QueryContextChannelBinding(SSPIInterface SecModule, SafeDeleteContext securityContext, ChannelBindingKind contextAttribute)
        {
            GlobalLog.Enter("QueryContextChannelBinding", contextAttribute.ToString());

            SafeFreeContextBufferChannelBinding result;
            
            int errorCode = SecModule.QueryContextChannelBinding(securityContext, contextAttribute , out result);

            if (result != null)
            {
                GlobalLog.Leave("QueryContextChannelBinding", Logging.HashString(result));
            }

            return result;
        }

 internal ChannelBinding GetChannelBinding(ChannelBindingKind kind)
 {
     return (Context == null) ? null : Context.GetChannelBinding(kind);
 }

 public static SafeFreeContextBufferChannelBinding QueryContextChannelBinding(SafeDeleteContext securityContext, ChannelBindingKind attribute)
 {
     SafeChannelBindingHandle bindingHandle = Interop.OpenSsl.QueryChannelBinding(securityContext.SslContext, attribute);
     var refHandle = bindingHandle == null ? null : new SafeFreeContextBufferChannelBinding(bindingHandle);
     return refHandle;
 }

 public int QueryContextChannelBinding(SafeDeleteContext phContext, ChannelBindingKind attribute,
     out SafeFreeContextBufferChannelBinding refHandle)
 {
     throw NotImplemented.ByDesignWithMessage(SR.net_MethodNotImplementedException);
 }

        internal ChannelBinding GetChannelBinding(ChannelBindingKind kind)
        {
            GlobalLog.Enter("SecureChannel#" + Logging.HashString(this) + "::GetChannelBindingToken", kind.ToString());

            ChannelBinding result = null;
            if (_securityContext != null)
            {
                result = SSPIWrapper.QueryContextChannelBinding(GlobalSSPI.SSPISecureChannel, _securityContext, kind);
            }

            GlobalLog.Leave("SecureChannel#" + Logging.HashString(this) + "::GetChannelBindingToken", Logging.HashString(result));
            return result;
        }

 private byte[] GetPrefixBytes(ChannelBindingKind kind)
 {
     if (kind == ChannelBindingKind.Endpoint)
     {
         return s_tlsServerEndPointByteArray;
     }
     else if (kind == ChannelBindingKind.Unique)
     {
         return s_tlsUniqueByteArray;
     }
     else
     {
         throw new NotSupportedException();
     }
 }

        internal ChannelBinding GetChannelBinding(ChannelBindingKind kind)
        {
            GlobalLog.Enter("SecureChannel#" + ValidationHelper.HashString(this) + "::GetChannelBindingToken", kind.ToString());

            ChannelBinding result = null;
            if (m_SecurityContext != null)
            {
                result = SSPIWrapper.QueryContextChannelBinding(m_SecModule, m_SecurityContext, (ContextAttribute)kind);
            }

            GlobalLog.Leave("SecureChannel#" + ValidationHelper.HashString(this) + "::GetChannelBindingToken", ValidationHelper.HashString(result));
            return result;
        }

 public override ChannelBinding GetChannelBinding(ChannelBindingKind kind)
 {
     return this.connectStream.GetChannelBinding(kind);
 }

        internal ChannelBinding GetChannelBinding(ChannelBindingKind kind)
        {
            GlobalLog.Enter("ConnectStream#" + ValidationHelper.HashString(this) + "::GetChannelBinding", kind.ToString());

            ChannelBinding binding = null;
            TlsStream tlsStream = m_Connection.NetworkStream as TlsStream;

            if (tlsStream != null)
            {
                binding = tlsStream.GetChannelBinding(kind);
            }

            GlobalLog.Leave("ConnectStream#" + ValidationHelper.HashString(this) + "::GetChannelBinding", ValidationHelper.HashString(binding));
            return binding;
        }