C# Shared.TcpConnection类代码示例

        public void Send100MBMessage()
        {
            long memoryUsage = Shared.GetCurrentMemoryUsage();

             _application.Settings.MaxMessageSize = 0;

             TcpConnection socket = new TcpConnection();
             socket.Connect(25);
             socket.Receive();

             socket.Send("HELO test.com\r\n");
             socket.Receive();

             // Build a large string...
             StringBuilder sb = new StringBuilder();
             sb.Append("A01");
             for (int i = 0; i < 10000; i++)
             {
            sb.Append("01234567890012345678900123456789001234567890012345678900123456789001234567890012345678900123456789001234567890\r\n");
             }
             int length = sb.Length;

             sb.Append(Environment.NewLine);

             socket.Send("MAIL FROM: [email protected]\r\n");
             socket.Receive();
             socket.Send("RCPT TO: [email protected]\r\n");
             socket.Receive();
             socket.Send("DATA\r\n");
             socket.Receive();

             for (int i = 1; i <= 100; i++)
             {
            Shared.AssertLowMemoryUsage(memoryUsage + 30);

            try
            {
               socket.Send(sb.ToString());
            }
            catch (Exception)
            {
               return;
            }

            if ((i % 10) == 0)
            {
               TestTracer.WriteTraceInfo("{0}/{1}", i, 1000);
            }
             }

             socket.Send("\r\n.\r\n");
             string result = socket.Receive();
             Assert.IsTrue(result.StartsWith("250"));

             socket.Send("QUIT\r\n");
             result = socket.Receive();
             socket.Disconnect();

             Pop3ClientSimulator.AssertMessageCount(_domain.Accounts[0].Address, "test", 1);
        }

        public void TestExcessiveDataInPOP3Conversation()
        {
            var sb = new StringBuilder();
             for (int i = 0; i < 100000; i++)
             {
            sb.Append("1234567890");
             }

             string command = "HELP " + sb;

             var socket = new TcpConnection();
             CustomAssert.IsTrue(socket.Connect(110));
             socket.Receive();
             socket.Send(command + "\r\n");

             try
             {
            string response = socket.Receive();
            CustomAssert.IsTrue(response.StartsWith("-ERR"));

            socket.Disconnect();
             }
             catch (IOException ex)
             {
            AssertIsConnectionTerminatedException(ex);
             }
        }

        public IMAPSimulator(string username, string password, string mailbox)
        {
            _tcpConnection = new TcpConnection();

             CustomAssert.IsTrue(ConnectAndLogon(username, password));
             CustomAssert.IsTrue(SelectFolder(mailbox));
        }

        public void TestExcessiveDataInIMAPConversation()
        {
            var sb = new StringBuilder();
             for (int i = 0; i < 100000; i++)
             {
            sb.Append("1234567890");
             }

             sb.Append(".com\r\n");

             string command = "A03 NOOP " + sb;

             var socket = new TcpConnection();
             CustomAssert.IsTrue(socket.Connect(143));
             socket.Receive();
             socket.Send(command);

             try
             {
            string response = socket.Receive();
            CustomAssert.IsTrue(response.StartsWith("* BYE"));
             }
             catch (System.IO.IOException ex)
             {
            AssertIsConnectionTerminatedException(ex);
             }

             socket.Disconnect();
        }

        public void SetupSSLPort()
        {
            _application.Settings.Logging.Enabled = true;
             _application.Settings.Logging.LogTCPIP = true;
             _application.Settings.Logging.EnableLiveLogging(true);

             var cs = new TcpConnection();
             if (!cs.Connect(250))
            CustomAssert.Fail("Could not connect to SSL server.");

             cs.Disconnect();

             for (int i = 0; i <= 40; i++)
             {
            CustomAssert.IsTrue(i != 40);

            string liveLog = _application.Settings.Logging.LiveLog;
            if (liveLog.Contains("SSL handshake with client failed."))
               break;

            Thread.Sleep(250);
             }

             _application.Settings.Logging.EnableLiveLogging(false);
        }

        public void ConnectionCountShouldDecreaseWhenClientDisconnects()
        {
            var countBefore = _application.Status.get_SessionCount(eSessionType.eSTSMTP);

             using (var tcpConn = new TcpConnection(false))
             {
            tcpConn.Connect(25001);

            // Since there may be other connections lingering, we just check the increased count if
            // it was zero previous to this test. Otherwise we might end up with false positives.
            if (countBefore == 0)
            {
               RetryHelper.TryAction(TimeSpan.FromSeconds(10), () =>
               {
                  var countWhileConnected = _application.Status.get_SessionCount(eSessionType.eSTSMTP);

                  Assert.AreEqual(1, countWhileConnected);
               });

            }
             }

             RetryHelper.TryAction(TimeSpan.FromSeconds(10), () =>
             {
            var countAfter = _application.Status.get_SessionCount(eSessionType.eSTSMTP);

            Assert.GreaterOrEqual(countBefore, countAfter);
             });
        }

        public void IfStartTlsNotEnabledStartTlsShouldNotBeShownInEhloResponse()
        {
            var smtpClientSimulator = new TcpConnection();
             smtpClientSimulator.Connect(25);
             var data1 = smtpClientSimulator.Receive();
             var data = smtpClientSimulator.SendAndReceive("EHLO example.com\r\n");

             Assert.IsFalse(data.Contains("STARTTLS"));
        }

        public void IfStlsRequiredLogonShouldFailIfNoStls()
        {
            var smtpClientSimulator = new TcpConnection();
             smtpClientSimulator.Connect(25003);
             var banner = smtpClientSimulator.Receive();
             var capabilities1 = smtpClientSimulator.SendAndReceive("EHLO example.com\r\n");
             Assert.IsTrue(capabilities1.Contains("STARTTLS"));

             var loginResult = smtpClientSimulator.SendAndReceive("AUTH LOGIN\r\n");
             Assert.IsTrue(loginResult.StartsWith("530 Must issue STARTTLS first."));
        }

        public void TestConnectingToImapServerIncreasesImapSessionCount()
        {
            var app = SingletonProvider<TestSetup>.Instance.GetApp();
             var status = app.Status;
             int countBefore = status.get_SessionCount(eSessionType.eSTIMAP);

             using (var conn1 = new TcpConnection())
             {
            Assert.IsTrue(conn1.Connect(143));
            CustomAsserts.AssertSessionCount(eSessionType.eSTIMAP, countBefore + 1);
             }
        }

        public void TestConnectingToPop3ServerIncreasesPop3SessionCount()
        {
            var app = SingletonProvider<TestSetup>.Instance.GetApp();
             var status = app.Status;
             int countBefore = status.get_SessionCount(eSessionType.eSTPOP3);

             using (var conn1 = new TcpConnection())
             {
            CustomAssert.IsTrue(conn1.Connect(110));
            TestSetup.AssertSessionCount(eSessionType.eSTPOP3, countBefore + 1);
             }
        }

        public void IfStlsOptionalButSslRequiredByIpRangeForAuthThenAuthShouldFail()
        {
            var range = SingletonProvider<TestSetup>.Instance.GetApp().Settings.SecurityRanges.get_ItemByName("My computer");
             range.RequireSSLTLSForAuth = true;
             range.Save();

             var smtpClientSimulator = new TcpConnection();
             smtpClientSimulator.Connect(25002);
             var banner = smtpClientSimulator.Receive();
             var capabilities1 = smtpClientSimulator.SendAndReceive("EHLO example.com\r\n");
             Assert.IsTrue(capabilities1.Contains("STARTTLS"));

             var loginResult = smtpClientSimulator.SendAndReceive("AUTH LOGIN\r\n");
             Assert.IsTrue(loginResult.StartsWith("530 A SSL/TLS-connection is required for authentication.")); // must run starttls first.
        }

        public void HandshakeCompletionShouldBeLoggedWithCipherDetails()
        {
            var smtpClientSimulator = new TcpConnection();
             smtpClientSimulator.Connect(25002);
             var banner = smtpClientSimulator.Receive();
             var capabilities1 = smtpClientSimulator.SendAndReceive("EHLO example.com\r\n");
             Assert.IsTrue(capabilities1.Contains("STARTTLS"));

             smtpClientSimulator.SendAndReceive("STARTTLS\r\n");
             smtpClientSimulator.HandshakeAsClient();

             var capabilities2 = smtpClientSimulator.SendAndReceive("EHLO example.com\r\n");

             var default_log = LogHandler.ReadCurrentDefaultLog();

             Assert.IsTrue(default_log.Contains("Version: TLS"));
             Assert.IsTrue(default_log.Contains("Cipher: "));
             Assert.IsTrue(default_log.Contains("Bits: "));
        }

        public void TestManyTCPIPConnections()
        {
            LogHandler.DeleteCurrentDefaultLog();

             const int count = 1000;

             List<TcpConnection> sockets = new List<TcpConnection>();

             for (int i = 1; i <= count; i++)
             {
            TcpConnection socket = new TcpConnection();
            Assert.IsTrue(socket.Connect(25));

            if ((i % 10) == 0)
            {
               TestTracer.WriteTraceInfo("{0}/{1}", i, 1000);
            }

            sockets.Add(socket);
             }

             foreach (TcpConnection socket in sockets)
             {
            socket.Disconnect();
             }

             RetryHelper.TryAction(() =>
            {
               string log = LogHandler.ReadCurrentDefaultLog();

               string connectionCreated = "TCP - 127.0.0.1 connected to 127.0.0.1:25.";
               string connectionEnded = "Ending session ";

               var created = Regex.Matches(log, connectionCreated);
               var ended = Regex.Matches(log, connectionEnded);

               Assert.AreEqual(count, created.Count);
               Assert.AreEqual(count, ended.Count);

            }, TimeSpan.FromSeconds(1),TimeSpan.FromSeconds(30));
        }

        public void AuthShouldUpdateLastLogonTime()
        {
            Account account = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "[email protected]", "test");
             DateTime lastLogonTimeBefore = Convert.ToDateTime(account.LastLogonTime);

             Thread.Sleep(1000);
             var sock = new TcpConnection();
             sock.Connect(25);
             CustomAssert.IsTrue(sock.Receive().StartsWith("220"));
             sock.Send("EHLO test.com\r\n");
             CustomAssert.IsTrue(sock.Receive().StartsWith("250"));

             string base64EncodedUsername = EncodeBase64("[email protected]");
             sock.Send("AUTH LOGIN " + base64EncodedUsername + "\r\n");
             CustomAssert.IsTrue(sock.Receive().StartsWith("334"));

             sock.Send(EncodeBase64("test") + "\r\n");
             CustomAssert.IsTrue(sock.Receive().StartsWith("235"));

             DateTime lastLogonTimeAfter =
            Convert.ToDateTime(SingletonProvider<TestSetup>.Instance.GetApp().Domains[0].Accounts[0].LastLogonTime);
             CustomAssert.AreNotEqual(lastLogonTimeBefore, lastLogonTimeAfter);
        }

        public void TestLongSMTPCommand()
        {
            var socket = new TcpConnection();
             socket.Connect(25);

             // Build a large string...
             var sb = new StringBuilder();
             sb.Append("A01");
             for (int i = 0; i < 1000000; i++)
             {
            sb.Append("01234567890");
             }

             sb.Append(Environment.NewLine);

             for (int i = 0; i < 100; i++)
             {
            try
            {
               socket.Send(sb.ToString());
            }
            catch (Exception)
            {
               return;
            }

            if ((i % 10) == 0)
            {
               TestTracer.WriteTraceInfo("{0}/{1}", i, 100);
            }
             }

             socket.Send("\r\n");
             socket.Receive();

             socket.Disconnect();
        }