예제 #1
0
        public void GetVerb_SupportedCommands_ReturnProperVerb()
        {
            // Arrange
            var testCommands = new KeyValuePair <string, SmtpVerb>[]
            {
                new KeyValuePair <string, SmtpVerb>("HELO", SmtpVerb.Hello),
                new KeyValuePair <string, SmtpVerb>("EHLO", SmtpVerb.ExtendedHello),
                new KeyValuePair <string, SmtpVerb>("MAIL", SmtpVerb.Mail),
                new KeyValuePair <string, SmtpVerb>("RCPT", SmtpVerb.Recipient),
                new KeyValuePair <string, SmtpVerb>("DATA", SmtpVerb.Data),
                new KeyValuePair <string, SmtpVerb>("RSET", SmtpVerb.Reset),
                new KeyValuePair <string, SmtpVerb>("VRFY", SmtpVerb.Verify),
                new KeyValuePair <string, SmtpVerb>("EXPN", SmtpVerb.Expand),
                new KeyValuePair <string, SmtpVerb>("HELP", SmtpVerb.Help),
                new KeyValuePair <string, SmtpVerb>("NOOP", SmtpVerb.NoOp),
                new KeyValuePair <string, SmtpVerb>("QUIT", SmtpVerb.Quit),
            };

            foreach (var commandPair in testCommands)
            {
                // Act
                var resultingVerb = SmtpCommand.GetVerb(commandPair.Key);

                // Assert
                Assert.AreEqual(commandPair.Value, resultingVerb,
                                string.Format("Command string {0} did not return verb {1}",
                                              commandPair.Key, commandPair.Value));
            }
        }
예제 #2
0
 public void Parsing_ArgsSeparatedByColon()
 {
     SmtpCommand command = new SmtpCommand("DATA:ARGS");
     Assert.True(command.IsValid);
     Assert.Equal("DATA", command.Verb);
     Assert.Equal("ARGS", command.ArgumentsText);
 }
예제 #3
0
        public async Task ProcessAsync(IConnection connection, SmtpCommand command)
        {
            X509Certificate certificate = connection.Server.Behaviour.GetSSLCertificate(connection);

            if (certificate == null)
            {
                await connection.WriteResponseAsync(new SmtpResponse(StandardSmtpResponseCode.CommandNotImplemented, "TLS configuration error - no certificate"));
                return;
            }

            await connection.WriteResponseAsync(new SmtpResponse(StandardSmtpResponseCode.ServiceReady,
                                                      "Ready to start TLS"));

#pragma warning disable 0618
            var sslProtos = SslProtocols.Ssl2 | SslProtocols.Ssl3 | SslProtocols.Tls;
#pragma warning restore 0618

            await connection.ApplyStreamFilterAsync(async stream =>
                                                     {
                                                         SslStream sslStream = new SslStream(stream);
                                                         await sslStream.AuthenticateAsServerAsync(certificate
                                                             , false,
                                                             sslProtos,
                                                             false);
                                                         return sslStream;
                                                     });

            connection.Session.SecureConnection = true;
        }
예제 #4
0
 public void Parsing_SingleToken()
 {
     SmtpCommand command = new SmtpCommand("DATA");
     Assert.True(command.IsValid);
     Assert.Equal("DATA", command.Verb);
     Assert.Equal("", command.ArgumentsText);
 }
예제 #5
0
        public void Parsing_ArgsSeparatedByColon()
        {
            var command = new SmtpCommand("DATA:ARGS");

            Assert.True(command.IsValid);
            Assert.Equal("DATA", command.Verb);
            Assert.Equal("ARGS", command.ArgumentsText);
        }
예제 #6
0
        public void Parsing_ArgsSeparatedBySpace()
        {
            SmtpCommand command = new SmtpCommand("DATA ARGS");

            Assert.IsTrue(command.IsValid);
            Assert.AreEqual("DATA", command.Verb);
            Assert.AreEqual("ARGS", command.ArgumentsText);
        }
예제 #7
0
        public void Parsing_SingleToken()
        {
            var command = new SmtpCommand("DATA");

            Assert.True(command.IsValid);
            Assert.Equal("DATA", command.Verb);
            Assert.Equal("", command.ArgumentsText);
        }
예제 #8
0
        public void Parsing_SingleToken()
        {
            SmtpCommand command = new SmtpCommand("DATA");

            Assert.IsTrue(command.IsValid);
            Assert.AreEqual("DATA", command.Verb);
            Assert.AreEqual("", command.ArgumentsText);
            Assert.AreEqual(0, command.Arguments.Length);
        }
예제 #9
0
        public async Task ProcessAsync(IConnection connection, SmtpCommand command)
        {
            await connection.WriteResponseAsync(new SmtpResponse(StandardSmtpResponseCode.ClosingTransmissionChannel,
                                                                 "Goodbye"));

            await connection.CloseConnectionAsync();

            connection.Session.CompletedNormally = true;
        }
예제 #10
0
        private void CheckDataForCommand(string dataRead)
        {
            var parseResult = SmtpCommand.Parse(dataRead);

            if (parseResult.Success)
            {
                LastCommand = parseResult.Result;
            }
        }
예제 #11
0
        /// <summary>
        /// Execute the command.
        /// </summary>
        /// <param name="command">The command to execute.</param>
        /// <param name="context">The execution context to operate on.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns>A task which asynchronously performs the execution.</returns>
        static async Task <bool> ExecuteAsync(SmtpCommand command, SmtpSessionContext context, CancellationToken cancellationToken)
        {
            context.RaiseCommandExecuting(command);

            var result = await command.ExecuteAsync(context, cancellationToken);

            context.RaiseCommandExecuted(command);

            return(result);
        }
예제 #12
0
 public void Parsing_MailFrom_WithDisplayName()
 {
     SmtpCommand command = new SmtpCommand("MAIL FROM:<Robert Wood<*****@*****.**>> ARG1 ARG2");
     Assert.IsTrue(command.IsValid);
     Assert.AreEqual("MAIL", command.Verb);
     Assert.AreEqual("FROM:<Robert Wood<*****@*****.**>> ARG1 ARG2", command.ArgumentsText);
     Assert.AreEqual("FROM", command.Arguments[0]);
     Assert.AreEqual("<Robert Wood<*****@*****.**>>", command.Arguments[1]);
     Assert.AreEqual("ARG1", command.Arguments[2]);
     Assert.AreEqual("ARG2", command.Arguments[3]);
 }
예제 #13
0
 public void Parsing_MailFrom_EmailOnly()
 {
     SmtpCommand command = new SmtpCommand("MAIL FROM:<*****@*****.**> ARG1 ARG2");
     Assert.IsTrue(command.IsValid);
     Assert.AreEqual("MAIL", command.Verb);
     Assert.AreEqual("FROM:<*****@*****.**> ARG1 ARG2", command.ArgumentsText);
     Assert.AreEqual("FROM", command.Arguments[0]);
     Assert.AreEqual("<*****@*****.**>", command.Arguments[1]);
     Assert.AreEqual("ARG1", command.Arguments[2]);
     Assert.AreEqual("ARG2", command.Arguments[3]);
 }
예제 #14
0
        public void Parsing_MailFrom_WithDisplayName()
        {
            SmtpCommand command = new SmtpCommand("MAIL FROM:<Robert Wood<*****@*****.**>> ARG1 ARG2");

            Assert.IsTrue(command.IsValid);
            Assert.AreEqual("MAIL", command.Verb);
            Assert.AreEqual("FROM:<Robert Wood<*****@*****.**>> ARG1 ARG2", command.ArgumentsText);
            Assert.AreEqual("FROM", command.Arguments[0]);
            Assert.AreEqual("<Robert Wood<*****@*****.**>>", command.Arguments[1]);
            Assert.AreEqual("ARG1", command.Arguments[2]);
            Assert.AreEqual("ARG2", command.Arguments[3]);
        }
예제 #15
0
        public void Parsing_MailFrom_EmailOnly()
        {
            SmtpCommand command = new SmtpCommand("MAIL FROM:<*****@*****.**> ARG1 ARG2");

            Assert.IsTrue(command.IsValid);
            Assert.AreEqual("MAIL", command.Verb);
            Assert.AreEqual("FROM:<*****@*****.**> ARG1 ARG2", command.ArgumentsText);
            Assert.AreEqual("FROM", command.Arguments[0]);
            Assert.AreEqual("<*****@*****.**>", command.Arguments[1]);
            Assert.AreEqual("ARG1", command.Arguments[2]);
            Assert.AreEqual("ARG2", command.Arguments[3]);
        }
예제 #16
0
        void QueueCommand(SmtpCommand type, string command)
        {
            if (queue == null)
            {
                queue = new MemoryBlockStream();
            }

            var bytes = Encoding.UTF8.GetBytes(command + "\r\n");

            queue.Write(bytes, 0, bytes.Length);
            queued.Add(type);
        }
예제 #17
0
        public void Parse_EHLOWithoutDomain_ReturnsTrueWithNoArguments()
        {
            // Arrange
            var testCommand = "EHLO SP";

            // Act
            var result = SmtpCommand.Parse(testCommand);

            // Assert
            Assert.IsTrue(result.Success);
            Assert.IsFalse(result.Result.Arguments.Any());
        }
예제 #18
0
        public async Task ProcessAsync(IConnection connection, SmtpCommand command)
        {
            if (!string.IsNullOrEmpty(connection.Session.ClientName))
            {
                await connection.WriteResponseAsync(new SmtpResponse(StandardSmtpResponseCode.BadSequenceOfCommands,
                                                                     "You already said HELO"));

                return;
            }

            connection.Session.ClientName = command.ArgumentsText ?? "";
            await connection.WriteResponseAsync(new SmtpResponse(StandardSmtpResponseCode.Ok, "Nice to meet you"));
        }
예제 #19
0
 private void CheckExpectedToken(byte[] token)
 {
     this.TrimStart();
     if (token.Length >= this.RemainingBufferLength)
     {
         throw new FormatException("Expected token is missing");
     }
     if (!SmtpCommand.CompareArg(token, this.commandBytes, this.currentOffset, token.Length))
     {
         throw new FormatException("Expected token is missing");
     }
     this.currentOffset += token.Length;
 }
예제 #20
0
        public async Task ProcessAsync(IConnection connection, SmtpCommand command)
        {
            if (connection.CurrentMessage != null)
            {
                await connection.WriteResponseAsync(new SmtpResponse(StandardSmtpResponseCode.BadSequenceOfCommands,
                                                                     "You already told me who the message was from"));

                return;
            }

            if (command.ArgumentsText.Length == 0)
            {
                await connection.WriteResponseAsync(
                    new SmtpResponse(StandardSmtpResponseCode.SyntaxErrorInCommandArguments,
                                     "Must specify from address or <>"));

                return;
            }

            var argumentsParser = new ArgumentsParser(command.ArgumentsText);
            var arguments       = argumentsParser.Arguments;

            var from = arguments.First();

            if (from.StartsWith("<"))
            {
                from = from.Remove(0, 1);
            }

            if (from.EndsWith(">"))
            {
                from = from.Remove(from.Length - 1, 1);
            }

            connection.Server.Behaviour.OnMessageStart(connection, from);
            connection.NewMessage();
            connection.CurrentMessage.ReceivedDate = _currentDateTimeProvider.GetCurrentDateTime();
            connection.CurrentMessage.From         = from;

            try
            {
                await ParameterProcessorMap.ProcessAsync(connection, arguments.Skip(1).ToArray(), true);

                await connection.WriteResponseAsync(new SmtpResponse(StandardSmtpResponseCode.Ok, "New message started"));
            }
            catch
            {
                connection.AbortMessage();
                throw;
            }
        }
예제 #21
0
        /// <summary>
        /// Try to accept the command given the current state.
        /// </summary>
        /// <param name="command">The command to accept.</param>
        /// <param name="errorResponse">The error response to display if the command was not accepted.</param>
        /// <returns>true if the command could be accepted, false if not.</returns>
        public bool TryAccept(SmtpCommand command, out SmtpResponse errorResponse)
        {
            errorResponse = null;

            if (_state.Transitions.TryGetValue(command.Name, out var transition) == false || transition.CanAccept(_context) == false)
            {
                var commands = _state.Transitions.Where(t => t.Value.CanAccept(_context)).Select(t => t.Key);

                errorResponse = new SmtpResponse(SmtpReplyCode.SyntaxError, $"expected {string.Join("/", commands)}");
                return(false);
            }

            _transition = transition;
            return(true);
        }
예제 #22
0
        public override async Task ProcessAsync(IConnection connection, SmtpCommand command)
        {
            if (connection.CurrentMessage != null && connection.CurrentMessage.EightBitTransport)
            {
                connection.SetReaderEncoding(Encoding.UTF8);
            }

            try
            {
                await base.ProcessAsync(connection, command);
            }
            finally
            {
                connection.SetReaderEncodingToDefault();
            }
        }
예제 #23
0
        public async virtual Task ProcessAsync(IConnection connection, SmtpCommand command)
        {
            SmtpCommand subrequest = new SmtpCommand(command.ArgumentsText);
            IVerb verbProcessor = SubVerbMap.GetVerbProcessor(subrequest.Verb);

            if (verbProcessor != null)
            {
                await verbProcessor.ProcessAsync(connection, subrequest);
            }
            else
            {
                await connection.WriteResponseAsync(
                    new SmtpResponse(StandardSmtpResponseCode.CommandParameterNotImplemented,
                                     "Subcommand {0} not implemented", subrequest.Verb));
            }
        }
예제 #24
0
        public async override Task ProcessAsync(IConnection connection, SmtpCommand command)
        {
            if (connection.CurrentMessage != null && connection.CurrentMessage.EightBitTransport)
            {
                connection.SetReaderEncoding(Encoding.UTF8);
            }

            try
            {
                await base.ProcessAsync(connection, command);
            }
            finally
            {
                connection.SetReaderEncodingToDefault();
            }
        }
예제 #25
0
        public virtual async Task ProcessAsync(IConnection connection, SmtpCommand command)
        {
            var subrequest    = new SmtpCommand(command.ArgumentsText);
            var verbProcessor = SubVerbMap.GetVerbProcessor(subrequest.Verb);

            if (verbProcessor != null)
            {
                await verbProcessor.ProcessAsync(connection, subrequest);
            }
            else
            {
                await connection.WriteResponseAsync(
                    new SmtpResponse(StandardSmtpResponseCode.CommandParameterNotImplemented,
                                     "Subcommand {0} not implemented", subrequest.Verb));
            }
        }
예제 #26
0
        public virtual void Process(IConnection connection, SmtpCommand command)
        {
            SmtpCommand subrequest    = new SmtpCommand(command.ArgumentsText);
            IVerb       verbProcessor = SubVerbMap.GetVerbProcessor(subrequest.Verb);

            if (verbProcessor != null)
            {
                verbProcessor.Process(connection, subrequest);
            }
            else
            {
                connection.WriteResponse(
                    new SmtpResponse(StandardSmtpResponseCode.CommandParameterNotImplemented,
                                     "Subcommand {0} not implemented", subrequest.Verb));
            }
        }
        public override void Process(IConnection connection, SmtpCommand command)
        {
            if (connection.CurrentMessage != null && connection.CurrentMessage.EightBitTransport)
            {
                connection.SetReaderEncoding(Encoding.Default);
            }

            try
            {
                base.Process(connection, command);
            }
            finally
            {
                connection.SetReaderEncodingToDefault();
            }
        }
예제 #28
0
        public override void Process(IConnection connection, SmtpCommand command)
        {
            if (connection.CurrentMessage != null && connection.CurrentMessage.EightBitTransport)
            {
                connection.SetReaderEncoding(Encoding.Default);
            }

            try
            {
                base.Process(connection, command);
            }
            finally
            {
                connection.SetReaderEncodingToDefault();
            }
        }
예제 #29
0
        public void Process(IConnection connection, SmtpCommand command)
        {
            connection.WriteResponse(new SmtpResponse(StandardSmtpResponseCode.ServiceReady,
                                                      "Ready to start TLS"));
            connection.ApplyStreamFilter(stream =>
            {
                SslStream sslStream = new SslStream(stream);
                sslStream.AuthenticateAsServer(
                    connection.Server.Behaviour.GetSSLCertificate(
                        connection), false,
                    SslProtocols.None,
                    false);
                return(sslStream);
            });

            connection.Session.SecureConnection = true;
        }
예제 #30
0
        public void ParseArguments_FromArgument_ReturnsArgumentPair()
        {
            // Arrange
            var testCommandParts = new string[]
            {
                "TEST", "FROM:[email protected]"
            };

            // Act
            var result = SmtpCommand.ParseArguments(testCommandParts);

            // Assert
            var spArgument = result.FirstOrDefault(m => m.Argument.Equals(SmtpArgumentName.From));

            Assert.IsNotNull(spArgument, "Did not return a From argument");
            Assert.AreEqual("*****@*****.**", spArgument.Value);
        }
예제 #31
0
        public void Parse_EHLOWithDomain_ReturnsResult()
        {
            // Arrange
            var testCommand = "EHLO SP test.com";

            // Act
            var result = SmtpCommand.Parse(testCommand);

            // Assert
            Assert.IsTrue(result.Success);
            Assert.AreEqual(SmtpVerb.ExtendedHello, result.Result.Verb);

            var spArgument = result.Result.Arguments.FirstOrDefault(m => m.Argument.Equals(SmtpArgumentName.Sp));

            Assert.IsNotNull(spArgument);
            Assert.AreEqual("test.com", spArgument.Value);
        }
예제 #32
0
        public void Process(IConnection connection, SmtpCommand command)
        {
            connection.WriteResponse(new SmtpResponse(StandardSmtpResponseCode.ServiceReady,
                                                      "Ready to start TLS"));
            connection.ApplyStreamFilter(stream =>
                                                     {
                                                         SslStream sslStream = new SslStream(stream);
                                                         sslStream.AuthenticateAsServer(
                                                             connection.Server.Behaviour.GetSSLCertificate(
                                                                 connection), false,
                                                             SslProtocols.Ssl2 | SslProtocols.Ssl3 | SslProtocols.Tls,
                                                             false);
                                                         return sslStream;
                                                     });

            connection.Session.SecureConnection = true;
        }
예제 #33
0
        /// <summary>
        /// Dispatches a command to the registered sub command matching the next verb in the command
        /// or writes an error to the client is no match was found.
        /// </summary>
        /// <param name="connection">The connection<see cref="Rnwood.SmtpServer.IConnection" />.</param>
        /// <param name="command">The command<see cref="Rnwood.SmtpServer.SmtpCommand" />.</param>
        /// <returns>
        /// A <see cref="System.Threading.Tasks.Task" /> representing the async operation.
        /// </returns>
        public virtual async Task Process(IConnection connection, SmtpCommand command)
        {
            SmtpCommand subrequest    = new SmtpCommand(command.ArgumentsText);
            IVerb       verbProcessor = this.SubVerbMap.GetVerbProcessor(subrequest.Verb);

            if (verbProcessor != null)
            {
                await verbProcessor.Process(connection, subrequest).ConfigureAwait(false);
            }
            else
            {
                await connection.WriteResponse(
                    new SmtpResponse(
                        StandardSmtpResponseCode.CommandParameterNotImplemented,
                        "Subcommand {0} not implemented",
                        subrequest.Verb)).ConfigureAwait(false);
            }
        }
예제 #34
0
        public override void Process(IConnection connection, SmtpCommand command)
        {
            if (_eightBitMessage)
            {
                connection.SetReaderEncoding(Encoding.Default);
            }

            try
            {
                base.Process(connection, command);
            }
            finally
            {
                if (_eightBitMessage)
                {
                    connection.SetReaderEncodingToDefault();
                }
            }
        }
예제 #35
0
        public override void Process(IConnection connection, SmtpCommand command)
        {
            if (_eightBitMessage)
            {
                connection.SetReaderEncoding(Encoding.Default);
            }

            try
            {
                base.Process(connection, command);
            }
            finally
            {
                if (_eightBitMessage)
                {
                    connection.SetReaderEncodingToDefault();
                }
            }
        }
예제 #36
0
        async ValueTask <SmtpCommand> ReadCommandAsync(ISessionContext context, CancellationToken cancellationToken)
        {
            var timeout = new CancellationTokenSource(context.ServerOptions.CommandWaitTimeout);

            var cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(timeout.Token, cancellationToken);

            try
            {
                SmtpCommand command = null;

                await context.Pipe.Input.ReadLineAsync(
                    buffer =>
                {
                    var parser = new SmtpParser(_commandFactory);

                    if (parser.TryMake(ref buffer, out command, out var errorResponse) == false)
                    {
                        throw new SmtpResponseException(errorResponse);
                    }

                    return(Task.CompletedTask);
                },
                    cancellationTokenSource.Token).ConfigureAwait(false);

                return(command);
            }
            catch (OperationCanceledException)
            {
                if (timeout.IsCancellationRequested)
                {
                    throw new SmtpResponseException(new SmtpResponse(SmtpReplyCode.ServiceClosingTransmissionChannel, "Timeout whilst waiting for input."), true);
                }

                throw new SmtpResponseException(new SmtpResponse(SmtpReplyCode.ServiceClosingTransmissionChannel, "The session has be cancelled."), true);
            }
            finally
            {
                timeout.Dispose();
                cancellationTokenSource.Dispose();
            }
        }
예제 #37
0
        /// <inheritdoc/>
        public async Task Process(IConnection connection, SmtpCommand command)
        {
            X509Certificate certificate = await connection.Server.Behaviour.GetSSLCertificate(connection).ConfigureAwait(false);

            if (certificate == null)
            {
                await connection.WriteResponse(new SmtpResponse(StandardSmtpResponseCode.CommandNotImplemented, "TLS configuration error - no certificate")).ConfigureAwait(false);

                return;
            }

            await connection.WriteResponse(new SmtpResponse(
                                               StandardSmtpResponseCode.ServiceReady,
                                               "Ready to start TLS")).ConfigureAwait(false);

            SslProtocols sslProtos;

            string ver = Assembly.GetEntryAssembly()?.GetCustomAttribute <TargetFrameworkAttribute>()?.FrameworkName;

            if (ver == null || !ver.StartsWith(".NETCoreApp,"))
            {
                sslProtos = SslProtocols.Tls12 | SslProtocols.Tls | SslProtocols.Tls11 | SslProtocols.Ssl3 | SslProtocols.Ssl2;
            }
            else
            {
                sslProtos = SslProtocols.None;
            }

            await connection.ApplyStreamFilter(async stream =>
            {
                SslStream sslStream = new SslStream(stream);
                await sslStream.AuthenticateAsServerAsync(
                    certificate,
                    false,
                    sslProtos,
                    false).ConfigureAwait(false);
                return(sslStream);
            }).ConfigureAwait(false);

            connection.Session.SecureConnection = true;
        }
        public bool IsCommandValid(SmtpCommand command)
        {
            switch (command)
            {
                case SmtpCommand.Help:
                case SmtpCommand.Helo:
                case SmtpCommand.Ehlo:
                case SmtpCommand.Rset:
                    return true;
                case SmtpCommand.StartTls:
                    return HasHelo && !HasMailFrom;
                case SmtpCommand.Mail:
                    return HasHelo && !HasMailFrom;
                case SmtpCommand.Rcpt:
                    return HasMailFrom;
                case SmtpCommand.Data:
                    return HasRcptTo;
                case SmtpCommand.Quit:
                    return true;
            }

            return false;
        }
예제 #39
0
        public async Task ProcessAsync(IConnection connection, SmtpCommand command)
        {
            if (!string.IsNullOrEmpty(connection.Session.ClientName))
            {
                await connection.WriteResponseAsync(new SmtpResponse(StandardSmtpResponseCode.BadSequenceOfCommands,
                                                                     "You already said HELO"));

                return;
            }

            connection.Session.ClientName = command.ArgumentsText ?? "";

            var text = new StringBuilder();

            text.AppendLine("Nice to meet you.");

            foreach (var extnName in connection.ExtensionProcessors.SelectMany(extn => extn.EhloKeywords))
            {
                text.AppendLine(extnName);
            }

            await connection.WriteResponseAsync(new SmtpResponse(StandardSmtpResponseCode.Ok, text.ToString().TrimEnd()));
        }
예제 #40
0
        public void Process(IConnection connection, SmtpCommand command)
        {
            X509Certificate certificate = connection.Server.Behaviour.GetSSLCertificate(connection);

            if (certificate == null)
            {
                connection.WriteResponse(new SmtpResponse(StandardSmtpResponseCode.CommandNotImplemented, "TLS configuration error - no certificate"));
                return;
            }

            connection.WriteResponse(new SmtpResponse(StandardSmtpResponseCode.ServiceReady,
                                                      "Ready to start TLS"));
            connection.ApplyStreamFilter(stream =>
            {
                SslStream sslStream = new SslStream(stream);
                sslStream.AuthenticateAsServer(certificate
                                               , false,
                                               SslProtocols.Ssl2 | SslProtocols.Ssl3 | SslProtocols.Tls,
                                               false);
                return(sslStream);
            });

            connection.Session.SecureConnection = true;
        }
예제 #41
0
 /// <inheritdoc/>
 public async Task Process(IConnection connection, SmtpCommand command)
 {
     await connection.WriteResponse(new SmtpResponse(StandardSmtpResponseCode.OK, "Successfully did nothing")).ConfigureAwait(false);
 }
예제 #42
0
파일: NoopVerb.cs 프로젝트: rnwood/smtp4dev
 public async Task ProcessAsync(IConnection connection, SmtpCommand command)
 {
     await connection.WriteResponseAsync(new SmtpResponse(StandardSmtpResponseCode.OK, "Successfully did nothing"));
 }
예제 #43
0
파일: RsetVerb.cs 프로젝트: rnwood/smtp4dev
 public async Task ProcessAsync(IConnection connection, SmtpCommand command)
 {
     connection.AbortMessage();
     await connection.WriteResponseAsync(new SmtpResponse(StandardSmtpResponseCode.OK, "Rset completed"));
 }
예제 #44
0
        void QueueCommand(SmtpCommand type, string command)
        {
            if (queue == null)
                queue = new MemoryBlockStream ();

            var bytes = Encoding.UTF8.GetBytes (command + "\r\n");
            queue.Write (bytes, 0, bytes.Length);
            queued.Add (type);
        }
예제 #45
0
        void QueueCommand(SmtpCommand type, string command)
        {
            #if DEBUG
            Console.WriteLine ("C: {0}", command);
            #endif

            if (queue == null)
                queue = new MemoryBlockStream ();

            var bytes = Encoding.UTF8.GetBytes (command + "\r\n");
            queue.Write (bytes, 0, bytes.Length);
            queued.Add (type);
        }
예제 #46
0
 public void Process(IConnection connection, SmtpCommand command)
 {
     connection.WriteResponse(new SmtpResponse(StandardSmtpResponseCode.OK, "Sucessfully did nothing"));
 }
예제 #47
0
		void QueueCommand (SmtpCommand type, string command, CancellationToken cancellationToken)
		{
			var bytes = Encoding.UTF8.GetBytes (command + "\r\n");

			// Note: queued commands will be buffered by the stream
			Stream.Write (bytes, 0, bytes.Length, cancellationToken);
			queued.Add (type);
		}
예제 #48
0
 public void Process(IConnection connection, SmtpCommand command)
 {
     connection.AbortMessage();
     connection.WriteResponse(new SmtpResponse(StandardSmtpResponseCode.OK, "Rset completed"));
 }
예제 #49
0
        public void Process(IConnection connection, SmtpCommand command)
        {
            if (command.Arguments.Length > 0)
            {
                if (connection.Session.Authenticated)
                {
                    throw new SmtpServerException(new SmtpResponse(StandardSmtpResponseCode.BadSequenceOfCommands,
                                                                   "Already authenticated"));
                }

                string mechanismId = command.Arguments[0];
                IAuthMechanism mechanism = AuthExtensionProcessor.MechanismMap.Get(mechanismId);

                if (mechanism == null)
                {
                    throw new SmtpServerException(
                        new SmtpResponse(StandardSmtpResponseCode.CommandParameterNotImplemented,
                                         "Specified AUTH mechanism not supported"));
                }

                if (!AuthExtensionProcessor.IsMechanismEnabled(mechanism))
                {
                    throw new SmtpServerException(
                        new SmtpResponse(StandardSmtpResponseCode.AuthenticationFailure,
                                         "Specified AUTH mechanism not allowed right now (might require secure connection etc)"));
                }

                IAuthMechanismProcessor authMechanismProcessor =
                    mechanism.CreateAuthMechanismProcessor(connection);

                string initialData = null;
                if (command.Arguments.Length > 1)
                {
                    initialData = string.Join(" ", command.Arguments.Skip(1).ToArray());
                }

                AuthMechanismProcessorStatus status =
                    authMechanismProcessor.ProcessResponse(initialData);
                while (status == AuthMechanismProcessorStatus.Continue)
                {
                    string response = connection.ReadLine();

                    if (response == "*")
                    {
                        connection.WriteResponse(new SmtpResponse(StandardSmtpResponseCode.SyntaxErrorInCommandArguments, "Authentication aborted"));
                        return;
                    }

                    status = authMechanismProcessor.ProcessResponse(response);
                }

                if (status == AuthMechanismProcessorStatus.Success)
                {
                    connection.WriteResponse(new SmtpResponse(StandardSmtpResponseCode.AuthenticationOK,
                                                              "Authenticated OK"));
                    connection.Session.Authenticated = true;
                    connection.Session.AuthenticationCredentials = authMechanismProcessor.Credentials;
                }
                else
                {
                    connection.WriteResponse(new SmtpResponse(StandardSmtpResponseCode.AuthenticationFailure,
                                                              "Authentication failure"));
                }
            }
            else
            {
                throw new SmtpServerException(new SmtpResponse(StandardSmtpResponseCode.SyntaxErrorInCommandArguments,
                                                               "Must specify AUTH mechanism as a parameter"));
            }
        }