IsCommandValid() public method

public IsCommandValid ( SmtpCommand command ) : bool
command SmtpCommand
return bool
        public void RcptToAfterMailFromShouldSucceed()
        {
            var state = new SmtpServerSessionState()
            {
                HasHelo = true,
                HasMailFrom = true,
                HasRcptTo = false
            };

            Assert.True(state.IsCommandValid(SmtpCommand.Rcpt));
        }
        public void DataBeforeRcptToShouldFail()
        {
            var state = new SmtpServerSessionState()
            {
                HasHelo = true,
                HasMailFrom = true,
                HasRcptTo = false
            };

            Assert.IsFalse(state.IsCommandValid(SmtpCommand.Data));
        }
        public void MailFromAfterHeloShouldFail()
        {
            var state = new SmtpServerSessionState()
            {
                HasHelo = true,
                HasMailFrom = false,
                HasRcptTo = false
            };

            Assert.True(state.IsCommandValid(SmtpCommand.Mail));
        }
Esempio n. 4
0
        public async Task HandleConnection(IConnection connection)
        {
            _connection = connection;

            try
            {
                await SendBanner();

                while (true)
                {
                    _connection.SetTimeout(_configuration.EnvelopeCommandTimeout);

                    var data = await ReadUntilNewLine(_connection);

                    _log.LogInfo(new LogEvent()
                    {
                        Message        = data,
                        RemoteEndpoint = _connection.RemoteEndpoint,
                        SessionId      = _connection.SessionId
                    });

                    var command = CommandParser.ParseCommand(data);

                    if (!_state.IsCommandValid(command))
                    {
                        await SendCommandResult(new SmtpCommandReply(503, "bad sequence of commands"));

                        continue;
                    }

                    switch (command)
                    {
                    case SmtpCommand.Help:
                        await HandleHelp();

                        break;

                    case SmtpCommand.Rset:
                        await HandleRset();

                        _state.HasMailFrom = false;
                        _state.HasRcptTo   = false;
                        break;

                    case SmtpCommand.Helo:
                        await HandleHelo(data);

                        break;

                    case SmtpCommand.Ehlo:
                        await HandleEhlo(data);

                        break;

                    case SmtpCommand.StartTls:
                        await HandleStartTls();

                        break;

                    case SmtpCommand.Mail:
                        await HandleMailFrom(data);

                        break;

                    case SmtpCommand.Rcpt:
                        await HandleRcptTo(data);

                        break;

                    case SmtpCommand.Data:
                        await HandleData();

                        break;

                    case SmtpCommand.Quit:
                        await HandleQuit();

                        throw new DisconnectedException();
                    }
                }
            }
            catch (DisconnectedException)
            {
                // Connection gone.
            }
        }
        public void DataAfterRpptToShouldSucceed()
        {
            var state = new SmtpServerSessionState()
            {
                HasHelo = true,
                HasMailFrom = true,
                HasRcptTo = true
            };

            Assert.True(state.IsCommandValid(SmtpCommand.Data));
        }