[System]: SslStream.Flush() now flushes the underlying stream. Bug #57528. (#5569)

[mono.git] / mcs / class / System / System.Net.Security / SslStream.cs

diff --git a/mcs/class/System/System.Net.Security/SslStream.cs b/mcs/class/System/System.Net.Security/SslStream.cs
index 603a18b0cf183695b1d0a6ba39a9bb4d235d09fa..a536f3bb8224edc5cd599737bca41c05631efc3e 100644 (file)
--- a/mcs/class/System/System.Net.Security/SslStream.cs
+++ b/mcs/class/System/System.Net.Security/SslStream.cs
@@ -39,6 +39,7 @@ using Mono.Security.Interface;
 using CipherAlgorithmType = System.Security.Authentication.CipherAlgorithmType;
 using HashAlgorithmType = System.Security.Authentication.HashAlgorithmType;
 using ExchangeAlgorithmType = System.Security.Authentication.ExchangeAlgorithmType;
+#endif
 
 using System.IO;
 using System.Net;
@@ -73,6 +74,7 @@ namespace System.Net.Security
 
        public class SslStream : AuthenticatedStream
        {
+#if SECURITY_DEP
                MonoTlsProvider provider;
                IMonoSslStream impl;
 
@@ -104,7 +106,7 @@ namespace System.Net.Security
                        : base (innerStream, leaveInnerStreamOpen)
                {
                        provider = GetProvider ();
-                       impl = provider.CreateSslStream (innerStream, leaveInnerStreamOpen);
+                       impl = provider.CreateSslStreamInternal (this, innerStream, leaveInnerStreamOpen, null);
                }
 
                public SslStream (Stream innerStream, bool leaveInnerStreamOpen, RemoteCertificateValidationCallback userCertificateValidationCallback)
@@ -128,6 +130,19 @@ namespace System.Net.Security
                {
                }
 
+               internal SslStream (Stream innerStream, bool leaveInnerStreamOpen, MonoTlsProvider provider, MonoTlsSettings settings)
+                       : base (innerStream, leaveInnerStreamOpen)
+               {
+                       this.provider = provider;
+                       impl = provider.CreateSslStreamInternal (this, innerStream, leaveInnerStreamOpen, settings);
+               }
+
+               internal static IMonoSslStream CreateMonoSslStream (Stream innerStream, bool leaveInnerStreamOpen, MonoTlsProvider provider, MonoTlsSettings settings)
+               {
+                       var sslStream = new SslStream (innerStream, leaveInnerStreamOpen, provider, settings);
+                       return sslStream.Impl;
+               }
+
                public virtual void AuthenticateAsClient (string targetHost)
                {
                        Impl.AuthenticateAsClient (targetHost);
@@ -208,6 +223,11 @@ namespace System.Net.Security
                        return Impl.AuthenticateAsServerAsync (serverCertificate, clientCertificateRequired, enabledSslProtocols, checkCertificateRevocation);
                }
 
+               public virtual Task ShutdownAsync ()
+               {
+                       return Impl.ShutdownAsync ();
+               }
+
                public override bool IsAuthenticated {
                        get { return Impl.IsAuthenticated; }
                }
@@ -273,15 +293,15 @@ namespace System.Net.Security
                }
 
                public override bool CanRead {
-                       get { return Impl.CanRead; }
+                       get { return impl != null && impl.CanRead; }
                }
 
                public override bool CanTimeout {
-                       get { return Impl.CanTimeout; }
+                       get { return InnerStream.CanTimeout; }
                }
 
                public override bool CanWrite {
-                       get { return Impl.CanWrite; }
+                       get { return impl != null && impl.CanWrite; }
                }
 
                public override int ReadTimeout {
@@ -317,7 +337,7 @@ namespace System.Net.Security
 
                public override void Flush ()
                {
-                       Impl.Flush ();
+                       InnerStream.Flush ();
                }
 
                void CheckDisposed ()
@@ -374,84 +394,257 @@ namespace System.Net.Security
                {
                        Impl.EndWrite (asyncResult);
                }
-       }
-}
 #else // !SECURITY_DEP
+               const string EXCEPTION_MESSAGE = "System.Net.Security.SslStream is not supported on the current platform.";
 
-using System.IO;
-using System.Threading.Tasks;
+               public SslStream (Stream innerStream)
+                       : this (innerStream, false)
+               {
+               }
 
-namespace System.Net.Security
-{
-       public class SslStream : Stream
-       {
-               public SslStream (object innerStream)
+               public SslStream (Stream innerStream, bool leaveInnerStreamOpen)
+                       : base (innerStream, leaveInnerStreamOpen)
                {
+                       throw new PlatformNotSupportedException (EXCEPTION_MESSAGE);
                }
 
-               public override bool CanRead {
-                       get {
-                               throw new NotImplementedException ();
-                       }
+               public SslStream (Stream innerStream, bool leaveInnerStreamOpen, RemoteCertificateValidationCallback userCertificateValidationCallback)
+                       : this (innerStream, leaveInnerStreamOpen)
+               {
+               }
+
+               public SslStream (Stream innerStream, bool leaveInnerStreamOpen, RemoteCertificateValidationCallback userCertificateValidationCallback, LocalCertificateSelectionCallback userCertificateSelectionCallback)
+                       : this (innerStream, leaveInnerStreamOpen)
+               {
+               }
+
+               public SslStream (Stream innerStream, bool leaveInnerStreamOpen, RemoteCertificateValidationCallback userCertificateValidationCallback, LocalCertificateSelectionCallback userCertificateSelectionCallback, EncryptionPolicy encryptionPolicy)
+                       : this (innerStream, leaveInnerStreamOpen)
+               {
+               }
+
+               public virtual void AuthenticateAsClient (string targetHost)
+               {
+                       throw new PlatformNotSupportedException (EXCEPTION_MESSAGE);
+               }
+
+               public virtual void AuthenticateAsClient (string targetHost, X509CertificateCollection clientCertificates, SslProtocols enabledSslProtocols, bool checkCertificateRevocation)
+               {
+                       throw new PlatformNotSupportedException (EXCEPTION_MESSAGE);
+               }
+
+               public virtual IAsyncResult BeginAuthenticateAsClient (string targetHost, AsyncCallback asyncCallback, object asyncState)
+               {
+                       throw new PlatformNotSupportedException (EXCEPTION_MESSAGE);
+               }
+
+               public virtual IAsyncResult BeginAuthenticateAsClient (string targetHost, X509CertificateCollection clientCertificates, SslProtocols enabledSslProtocols, bool checkCertificateRevocation, AsyncCallback asyncCallback, object asyncState)
+               {
+                       throw new PlatformNotSupportedException (EXCEPTION_MESSAGE);
+               }
+
+               public virtual void EndAuthenticateAsClient (IAsyncResult asyncResult)
+               {
+                       throw new PlatformNotSupportedException (EXCEPTION_MESSAGE);
+               }
+
+               public virtual void AuthenticateAsServer (X509Certificate serverCertificate)
+               {
+                       throw new PlatformNotSupportedException (EXCEPTION_MESSAGE);
+               }
+
+               public virtual void AuthenticateAsServer (X509Certificate serverCertificate, bool clientCertificateRequired, SslProtocols enabledSslProtocols, bool checkCertificateRevocation)
+               {
+                       throw new PlatformNotSupportedException (EXCEPTION_MESSAGE);
+               }
+
+               public virtual IAsyncResult BeginAuthenticateAsServer (X509Certificate serverCertificate, AsyncCallback asyncCallback, object asyncState)
+               {
+                       throw new PlatformNotSupportedException (EXCEPTION_MESSAGE);
+               }
+
+               public virtual IAsyncResult BeginAuthenticateAsServer (X509Certificate serverCertificate, bool clientCertificateRequired, SslProtocols enabledSslProtocols, bool checkCertificateRevocation, AsyncCallback asyncCallback, object asyncState)
+               {
+                       throw new PlatformNotSupportedException (EXCEPTION_MESSAGE);
+               }
+
+               public virtual void EndAuthenticateAsServer (IAsyncResult asyncResult)
+               {
+                       throw new PlatformNotSupportedException (EXCEPTION_MESSAGE);
+               }
+
+               public TransportContext TransportContext {
+                       get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); }
+               }
+
+               public virtual Task AuthenticateAsClientAsync (string targetHost)
+               {
+                       throw new PlatformNotSupportedException (EXCEPTION_MESSAGE);
+               }
+
+               public virtual Task AuthenticateAsClientAsync (string targetHost, X509CertificateCollection clientCertificates, SslProtocols enabledSslProtocols, bool checkCertificateRevocation)
+               {
+                       throw new PlatformNotSupportedException (EXCEPTION_MESSAGE);
+               }
+
+               public virtual Task AuthenticateAsServerAsync (X509Certificate serverCertificate)
+               {
+                       throw new PlatformNotSupportedException (EXCEPTION_MESSAGE);
+               }
+
+               public virtual Task AuthenticateAsServerAsync (X509Certificate serverCertificate, bool clientCertificateRequired, SslProtocols enabledSslProtocols, bool checkCertificateRevocation)
+               {
+                       throw new PlatformNotSupportedException (EXCEPTION_MESSAGE);
+               }
+
+               public override bool IsAuthenticated {
+                       get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); }
+               }
+
+               public override bool IsMutuallyAuthenticated {
+                       get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); }
+               }
+
+               public override bool IsEncrypted {
+                       get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); }
+               }
+
+               public override bool IsSigned {
+                       get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); }
+               }
+
+               public override bool IsServer {
+                       get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); }
+               }
+
+               public virtual SslProtocols SslProtocol {
+                       get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); }
+               }
+
+               public virtual bool CheckCertRevocationStatus {
+                       get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); }
+               }
+
+               public virtual X509Certificate LocalCertificate {
+                       get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); }
+               }
+
+               public virtual X509Certificate RemoteCertificate {
+                       get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); }
+               }
+
+               public virtual CipherAlgorithmType CipherAlgorithm {
+                       get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); }
+               }
+
+               public virtual int CipherStrength {
+                       get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); }
+               }
+
+               public virtual HashAlgorithmType HashAlgorithm {
+                       get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); }
+               }
+
+               public virtual int HashStrength {
+                       get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); }
+               }
+
+               public virtual ExchangeAlgorithmType KeyExchangeAlgorithm {
+                       get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); }
+               }
+
+               public virtual int KeyExchangeStrength {
+                       get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); }
                }
 
                public override bool CanSeek {
-                       get {
-                               throw new NotImplementedException ();
-                       }
+                       get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); }
+               }
+
+               public override bool CanRead {
+                       get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); }
+               }
+
+               public override bool CanTimeout {
+                       get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); }
                }
 
                public override bool CanWrite {
-                       get {
-                               throw new NotImplementedException ();
-                       }
+                       get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); }
+               }
+
+               public override int ReadTimeout {
+                       get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); }
+                       set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); }
+               }
+
+               public override int WriteTimeout {
+                       get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); }
+                       set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); }
                }
 
                public override long Length {
-                       get {
-                               throw new NotImplementedException ();
-                       }
+                       get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); }
                }
 
                public override long Position {
-                       get {
-                               throw new NotImplementedException ();
-                       }
+                       get { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); }
+                       set { throw new PlatformNotSupportedException (EXCEPTION_MESSAGE); }
+               }
 
-                       set {
-                               throw new NotImplementedException ();
-                       }
+               public override void SetLength (long value)
+               {
+                       throw new PlatformNotSupportedException (EXCEPTION_MESSAGE);
+               }
+
+               public override long Seek (long offset, SeekOrigin origin)
+               {
+                       throw new PlatformNotSupportedException (EXCEPTION_MESSAGE);
                }
 
                public override void Flush ()
                {
-                       throw new NotImplementedException ();
+                       throw new PlatformNotSupportedException (EXCEPTION_MESSAGE);
                }
 
-               public override int Read (System.Byte [] buffer, int offset, int count)
+               protected override void Dispose (bool disposing)
                {
-                       throw new NotImplementedException ();
                }
 
-               public override long Seek (long offset, SeekOrigin origin)
+               public override int Read (byte[] buffer, int offset, int count)
                {
-                       throw new NotImplementedException ();
+                       throw new PlatformNotSupportedException (EXCEPTION_MESSAGE);
                }
 
-               public override void SetLength (long value)
+               public void Write (byte[] buffer)
+               {
+                       throw new PlatformNotSupportedException (EXCEPTION_MESSAGE);
+               }
+
+               public override void Write (byte[] buffer, int offset, int count)
                {
-                       throw new NotImplementedException ();
+                       throw new PlatformNotSupportedException (EXCEPTION_MESSAGE);
                }
 
-               public override void Write (System.Byte [] buffer, int offset, int count)
+               public override IAsyncResult BeginRead (byte[] buffer, int offset, int count, AsyncCallback asyncCallback, object asyncState)
+               {
+                       throw new PlatformNotSupportedException (EXCEPTION_MESSAGE);
+               }
+
+               public override int EndRead (IAsyncResult asyncResult)
+               {
+                       throw new PlatformNotSupportedException (EXCEPTION_MESSAGE);
+               }
+
+               public override IAsyncResult BeginWrite (byte[] buffer, int offset, int count, AsyncCallback asyncCallback, object asyncState)
                {
-                       throw new NotImplementedException ();
+                       throw new PlatformNotSupportedException (EXCEPTION_MESSAGE);
                }
 
-               public virtual Task AuthenticateAsClientAsync (string targetHost, object clientCertificates, object enabledSslProtocols, bool checkCertificateRevocation)
+               public override void EndWrite (IAsyncResult asyncResult)
                {
-                       throw new NotImplementedException ();
+                       throw new PlatformNotSupportedException (EXCEPTION_MESSAGE);
                }
+#endif
        }
 }
-#endif