public void SmtpResponse() { SmtpResponse smtpResponse = new SmtpResponse(StandardSmtpResponseCode.ExceededStorageAllocation, "Blah"); SmtpServerException e = new SmtpServerException(smtpResponse); Assert.Same(smtpResponse, e.SmtpResponse); }
public SmtpResponseException(SmtpResponse response, string source) : base(new LocalizedString(response.ToString())) { MessageAction action; switch (response.SmtpResponseType) { case SmtpResponseType.Success: if (string.IsNullOrEmpty(source)) { throw new ArgumentException("Source must be provided for success smtp response type", "source"); } action = MessageAction.LogProcess; goto IL_6E; case SmtpResponseType.TransientError: action = MessageAction.Retry; goto IL_6E; case SmtpResponseType.PermanentError: action = MessageAction.NDR; goto IL_6E; } throw new ArgumentException("The smtp response type is not supported.", "response"); IL_6E: this.status = new MessageStatus(action, response, this, false, source); }
/* * /// <summary> * /// Return true if this is among the supported AUTH * /// types. * /// </summary> * /// <param name="authtypes"></param> * /// <returns></returns> * public bool IsSupported(SmtpAuthType[] authtypes) * { * log.Debug("CHECKING SUPPORTED TYPES"); * for (int i=0; i<authtypes.Length; i++) * { * log.Debug("CHECKING IF "+authtypes[i]+"="+SmtpAuthType.Login); * if (authtypes[i]==SmtpAuthType.Login) * { * return true; * } * } * return false; * } */ /// <summary> /// Return the 235 response code if valid, otherwise /// return the error. /// </summary> /// <param name="smtpProxy"></param> /// <param name="supportedAuthTypes">the supported auth types</param> /// <returns></returns> public SmtpResponse Negotiate(ISmtpProxy smtpProxy, String[] supportedAuthTypes) { SmtpResponse response = smtpProxy.Auth("login"); //log.Debug("RESPONSE WAS "+response.ResponseCode+" "+response.Message); if (response.ResponseCode != 334) { return(response); } Base64Encoder encoder = Base64Encoder.GetInstance(); response = smtpProxy.SendString(encoder.EncodeString(this.UserName, this._charEncoding)); if (response.ResponseCode != 334) { return(response); } response = smtpProxy.SendString(encoder.EncodeString(this.Password, this._charEncoding)); if (response.ResponseCode != 334) { // here it's an error return(response); } else { // here it's ok. return(response); } }
private static SmtpResponse GetExceptionSmtpResponse(IMessageConverter converter, Exception exception, string exceptionName, bool isPermanent) { SmtpResponse smtpResponse = SmtpResponse.Empty; if (exceptionName != null) { if (!(exceptionName == "MapiExceptionRpcServerTooBusy")) { if (!(exceptionName == "MapiExceptionSessionLimit")) { if (exceptionName == "MapiExceptionNotEnoughMemory") { smtpResponse = AckReason.MailboxServerNotEnoughMemory; } } else { smtpResponse = AckReason.MailboxMapiSessionLimit; } } else { smtpResponse = AckReason.MailboxServerTooBusy; } } return(StorageExceptionHandler.GetExceptionSmtpResponse(converter, exception, isPermanent, smtpResponse.StatusCode, smtpResponse.EnhancedStatusCode, smtpResponse.StatusText[0], true)); }
public async Task ProcessesMultiLineResponseCorrectly() { string responseLn1 = "250-smtp.com at your service, [123.456.789.101]"; string responseLn2 = "250-SIZE 35882577"; string responseLn3 = "250 STARTTLS"; IStreamReader reader = A.Fake <IStreamReader>(); A.CallTo(() => reader.ReadLineAsync()).ReturnsNextFromSequence( Task.FromResult(responseLn1), Task.FromResult(responseLn2), Task.FromResult(responseLn3)); SmtpResponse smtpResponse = await _smtpDeserializer.Deserialize(reader); Assert.That(smtpResponse.Responses.Count, Is.EqualTo(3)); Assert.That(smtpResponse.Responses[0].ResponseCode, Is.EqualTo(ResponseCode.Ok)); Assert.That(smtpResponse.Responses[0].Value, Is.EqualTo("smtp.com at your service, [123.456.789.101]")); Assert.That(smtpResponse.Responses[1].ResponseCode, Is.EqualTo(ResponseCode.Ok)); Assert.That(smtpResponse.Responses[1].Value, Is.EqualTo("SIZE 35882577")); Assert.That(smtpResponse.Responses[2].ResponseCode, Is.EqualTo(ResponseCode.Ok)); Assert.That(smtpResponse.Responses[2].Value, Is.EqualTo("STARTTLS")); }
private static MessageStatus GetMessageStatus(IMessageConverter converter, ConversionFailedException exception) { StorageExceptionHandler.LogException(converter, exception); SmtpResponse exceptionSmtpResponse = StorageExceptionHandler.GetExceptionSmtpResponse(converter, exception, true, "554", (ConversionFailureReason.ExceedsLimit == exception.ConversionFailureReason) ? "5.3.4" : "5.6.0", StorageExceptionHandler.GetReasonDescription(exception.ConversionFailureReason), true); return(new MessageStatus(MessageAction.NDR, exceptionSmtpResponse, exception, true)); }
private static MessageStatus GetMessageStatus(IMessageConverter converter, DataValidationException invalidDataException) { StorageExceptionHandler.LogException(converter, invalidDataException); SmtpResponse exceptionSmtpResponse = StorageExceptionHandler.GetExceptionSmtpResponse(converter, invalidDataException, true, converter.IsOutbound ? AckReason.OutboundInvalidDirectoryData : AckReason.InboundInvalidDirectoryData); return(new MessageStatus(MessageAction.NDR, exceptionSmtpResponse, invalidDataException)); }
public async Task <bool> TrySendSingleMailAsync( IMailReference mail, StreamWriter writer, StreamReader reader, CancellationToken token) { _log.Information($"Sending mail {mail.Id}"); IMailReadReference readMail = await _queue.OpenReadAsync(mail, token); _log.Information($"Sender: {readMail.Sender}, Recipients: {string.Join(",", readMail.Recipients)}"); SmtpResponse response = await ExecuteRemoteCommandAsync(writer, reader, $"MAIL FROM:<{readMail.Sender}>"); if (response.Code != SmtpReplyCode.Okay) { _log.Warning("Failed MAIL FROM, aborting"); return(false); } foreach (string recipient in readMail.Recipients) { response = await ExecuteRemoteCommandAsync(writer, reader, $"RCPT TO:<{recipient}>"); if (response.Code != SmtpReplyCode.Okay) { _log.Warning("Failed RCPT TO, aborting"); return(false); } } response = await ExecuteRemoteCommandAsync(writer, reader, "DATA"); if (response.Code != SmtpReplyCode.StartMail) { _log.Warning("Failed DATA, aborting"); return(false); } using (var mailReader = new StreamReader(readMail.BodyStream)) { string line = null; while (await mailReader.TryReadLineAsync(l => line = l, token)) { await writer.WriteLineAsync(line); } } await writer.WriteLineAsync("."); response = await ReadResponseAsync(reader); if (response.Code != SmtpReplyCode.Okay) { _log.Warning("Failed RCPT TO, aborting"); return(false); } await _queue.DeleteAsync(mail); return(true); }
public MessageStatus CreateStatus(Exception exception, Exception exceptionAssociatedWithHandler, IMessageConverter converter, TimeSpan fastRetryInterval, TimeSpan quarantineRetryInterval) { SmtpResponse exceptionSmtpResponse = StorageExceptionHandler.GetExceptionSmtpResponse(converter, exception, this.Category == Category.Permanent, this.GetEffectiveStatusCode(), this.GetEffectiveEnhancedStatusCode(exceptionAssociatedWithHandler), this.GetEffectivePrimaryStatusText(exceptionAssociatedWithHandler), this.IncludeDiagnosticStatusText); MessageStatus messageStatus = new MessageStatus(this.Action, exceptionSmtpResponse, exception, this.AppliesToAllRecipients); if (this.SpecifiedRetryInterval != null) { messageStatus.RetryInterval = new TimeSpan?(this.SpecifiedRetryInterval.Value); } else if (this.RetryInterval != RetryInterval.None) { if (this.RetryInterval == RetryInterval.QuarantinedRetry) { messageStatus.RetryInterval = new TimeSpan?(quarantineRetryInterval); } else { messageStatus.RetryInterval = new TimeSpan?(fastRetryInterval); } } if (this.CustomizeStatusCallback != null) { this.CustomizeStatusCallback(exceptionAssociatedWithHandler, converter, messageStatus); } return(messageStatus); }
void ThrowIfError(SmtpResponse status) { if (IsError(status)) { throw new SmtpException(status.StatusCode, status.Description); } }
private static MessageStatus GetMessageStatus(IMessageConverter converter, ADTransientException unavailableException) { StorageExceptionHandler.LogException(converter, unavailableException); SmtpResponse exceptionSmtpResponse = StorageExceptionHandler.GetExceptionSmtpResponse(converter, unavailableException, false); return(new MessageStatus(MessageAction.Retry, exceptionSmtpResponse, unavailableException)); }
public void SendNDRForFailedSubmission(IReadOnlyMailItem ndrMailItem, SmtpResponse ndrReason, DsnMailOutHandlerDelegate dsnMailOutHandler) { List <DsnRecipientInfo> list = new List <DsnRecipientInfo>(); list.Add(DsnGenerator.CreateDsnRecipientInfo(null, (string)ndrMailItem.From, null, ndrReason)); Components.DsnGenerator.GenerateNDRForInvalidAddresses(false, ndrMailItem, list, dsnMailOutHandler); }
private static bool CheckResponse(Socket socket, SmtpResponse response) { int byteCount = socket.Receive(m_Buffer, 0, m_Buffer.Length, SocketFlags.None); if (byteCount <= 2) { Shutdown(socket); return(false); } int resp = (int)response; byte dig1 = (byte)('0' + ((resp / 100) % 10)); byte dig2 = (byte)('0' + ((resp / 10) % 10)); byte dig3 = (byte)('0' + ((resp / 1) % 10)); bool valid = (m_Buffer[0] == dig1 && m_Buffer[1] == dig2 && m_Buffer[2] == dig3); if (!valid) { Shutdown(socket); } return(valid); }
public void SmtpResponse() { SmtpResponse smtpResponse = new SmtpResponse(StandardSmtpResponseCode.ExceededStorageAllocation, "Blah"); SmtpServerException e = new SmtpServerException(smtpResponse); Assert.AreSame(smtpResponse, e.SmtpResponse); }
public static string FlattenStatusText(SmtpResponse response) { if (response.StatusText == null || response.StatusText.Length == 0) { return(string.Empty); } if (response.StatusText.Length == 1) { return(response.StatusText[0]); } IEnumerator <string> enumerator = ((IEnumerable <string>)response.StatusText).GetEnumerator(); if (!enumerator.MoveNext()) { return(string.Empty); } StringBuilder stringBuilder = new StringBuilder(enumerator.Current); while (enumerator.MoveNext()) { stringBuilder.Append("; "); stringBuilder.Append(enumerator.Current); } return(stringBuilder.ToString()); }
public override void AckMailItem(AckStatus ackStatus, SmtpResponse smtpResponse, AckDetails details, TimeSpan?retryInterval, MessageTrackingSource source, string messageTrackingSourceContext, LatencyComponent deliveryComponent, string remoteMta, bool shadowed, string primaryServer, bool reportEndToEndLatencies) { if (this.recipientsPending != 0 && ackStatus == AckStatus.Success) { throw new InvalidOperationException("Cannot ack message successfully until all pending recipients have been acked"); } if (ackStatus == AckStatus.Pending) { this.recipientsPending = this.readyRecipients.Count; this.recipientEnumerator = this.mailItem.Recipients.GetEnumerator(); this.recipientEnumeratorAck = this.mailItem.Recipients.GetEnumerator(); this.result = null; } else { if (this.result == null) { this.result = new SmtpMailItemResult(); } this.result.MessageResponse = new AckStatusAndResponse(ackStatus, smtpResponse); this.mailItemSentForProcessing = true; } if (this.notificationHandler != null) { this.notificationHandler.AckMessage(ackStatus, smtpResponse); } }
/// <summary> /// Execute the command handler against the specified session context. /// </summary> /// <param name="context">The session context to execute the command handler against.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns>A task which asynchronously performs the execution.</returns> public virtual async Task ExecuteAsync(ISmtpSessionContext context, CancellationToken cancellationToken) { var retryCount = _maxRetries; while (retryCount-- > 0 && context.IsQuitRequested == false && cancellationToken.IsCancellationRequested == false) { var text = await context.Text.ReadLineAsync(cancellationToken).ConfigureAwait(false); SmtpCommand command; SmtpResponse errorResponse; if (TryAccept(context, text, out command, out errorResponse) == false) { var response = new SmtpResponse(errorResponse.ReplyCode, $"{errorResponse.Message}, {retryCount} retry(ies) remaining."); await context.Text.ReplyAsync(response, cancellationToken); continue; } // the command was a normal command so we can reset the retry count retryCount = _maxRetries; await ExecuteAsync(command, context, cancellationToken).ConfigureAwait(false); } }
private void Authenticate(Socket socket) { if (this.userName.Length > 0 || this.password.Length > 0) { SmtpResponse smtpResponse = SendData(socket, string.Format(CultureInfo.InvariantCulture, "EHLO {0}\r\n", Dns.GetHostName()), SmtpReplyCode.GenericSuccess); if (smtpResponse.Message.IndexOf("AUTH=LOGIN") >= 0) { SendData(socket, "AUTH LOGIN\r\n", SmtpReplyCode.AuthRequest); byte[] bytes = Encoding.UTF8.GetBytes(this.userName); SendData(socket, Convert.ToBase64String(bytes) + Environment.NewLine, SmtpReplyCode.AuthRequest); bytes = Encoding.UTF8.GetBytes(this.password); SendData(socket, Convert.ToBase64String(bytes) + Environment.NewLine, SmtpReplyCode.AuthSuccess); } else { throw new SmtpAuthenticationException(string.Format("Authentication to SMTP-server failed '{0}'. Code: {1} Message: {2}", this.host, smtpResponse.ReplyCode, smtpResponse.Message)); } } else { SendData(socket, string.Format(CultureInfo.InvariantCulture, "HELO {0}\r\n", Dns.GetHostName()), SmtpReplyCode.GenericSuccess); } }
public override void AckRecipient(AckStatus ackStatus, SmtpResponse smtpResponse) { TraceHelper.SmtpSendTracer.TracePass <string, string>(TraceHelper.MessageProbeActivityId, (long)this.GetHashCode(), "InboundProxyNextHopConnection.AckRecipient. Ackstatus = {0}. SmtpResponse = {1}", ackStatus.ToString(), smtpResponse.ToString()); if (!this.recipientEnumeratorAck.MoveNext() || this.recipientsPending <= 0) { throw new InvalidOperationException("AckRecipient called but no recipients left to ack"); } this.recipientsPending--; MailRecipient recipient = this.recipientEnumeratorAck.Current; switch (ackStatus) { case AckStatus.Pending: case AckStatus.Success: case AckStatus.Retry: case AckStatus.Fail: if (this.result == null) { this.result = new SmtpMailItemResult(); } if (this.result.RecipientResponses == null) { this.result.RecipientResponses = new Dictionary <MailRecipient, AckStatusAndResponse>(); } this.result.RecipientResponses.Add(recipient, new AckStatusAndResponse(ackStatus, smtpResponse)); if (this.notificationHandler != null) { this.notificationHandler.AckRecipient(ackStatus, smtpResponse, recipient); } return; default: throw new InvalidOperationException(string.Format("AckRecipient with status: {0} is invalid", ackStatus)); } }
public void Clone_should_copy_ReasonText() { var response = new SmtpResponse(250, "Text"); var cloned = response.Clone(); Assert.Equal(response.ResponseText, cloned.ResponseText); }
public void Clone_should_copy_ReasonCode() { var response = new SmtpResponse(250, ""); var cloned = response.Clone(); Assert.Equal(response.ResponseCode, cloned.ResponseCode); }
void CheckStatus(SmtpResponse status, int i) { if (((int)status.StatusCode) != i) { throw new SmtpException(status.StatusCode, status.Description); } }
private SmtpResponse Read() { byte [] buffer = new byte [512]; int position = 0; bool lastLine = false; do { CheckCancellation(); int readLength = stream.Read(buffer, position, buffer.Length - position); if (readLength > 0) { int available = position + readLength - 1; if (available > 4 && (buffer [available] == '\n' || buffer [available] == '\r')) { for (int index = available - 3; ; index--) { if (index < 0 || buffer [index] == '\n' || buffer [index] == '\r') { lastLine = buffer [index + 4] == ' '; break; } } } // move position position += readLength; // check if buffer is full if (position == buffer.Length) { byte [] newBuffer = new byte [buffer.Length * 2]; Array.Copy(buffer, 0, newBuffer, 0, buffer.Length); buffer = newBuffer; } } else { break; } } while (!lastLine); if (position > 0) { Encoding encoding = new ASCIIEncoding(); string line = encoding.GetString(buffer, 0, position - 1); // parse the line to the lastResponse object SmtpResponse response = SmtpResponse.Parse(line); return(response); } else { throw new System.IO.IOException("Connection closed"); } }
public SmtpResponseException(SmtpResponse response, MessageAction action) : base(new LocalizedString(response.ToString())) { if (action == MessageAction.Throw) { throw new ArgumentException("MessageAction.Throw is not supported.", "action"); } this.status = new MessageStatus(action, response, this); }
internal MessageStatus(MessageAction action, SmtpResponse smtpResponse, Exception exception, bool forAllRecipients, string source) { this.action = action; this.smtpResponse = smtpResponse; this.exception = exception; this.forAllRecipients = forAllRecipients; this.source = source; }
public void Equals_is_false_Additional_different_in_other_response() { var response1 = new SmtpResponse(250, "", new[] { "line" }); var response2 = new SmtpResponse(250, "", new[] { "different line" }); Assert.False(response1.Equals(response2)); Assert.False(response1.Equals((object)response2)); }
public void SmtpMultiLineTest() { var expected = "250-This is a\r\n250 Multi-line response\r\n"; var result = new SmtpResponse(ToStream(expected)); Assert.AreEqual(SmtpStatusCode.Ok, result.Status); Assert.AreEqual(expected, result.Message); }
public void SmtpSingleLineTest() { var expected = "220 Single-line response\r\n"; var result = new SmtpResponse(ToStream(expected)); Assert.AreEqual(SmtpStatusCode.ServiceReady, result.Status); Assert.AreEqual(expected, result.Message); }
public void Clone_should_deep_copy_Additional() { var response = new SmtpResponse(250, "", new[] { "additional" }); var cloned = response.Clone(); Assert.NotSame(response.AdditionalLines, cloned.AdditionalLines); Assert.Equal(response.AdditionalLines, cloned.AdditionalLines); }
public void Equals_is_false_ResponseText_doesnt_match() { var response1 = new SmtpResponse(250, "text"); var response2 = new SmtpResponse(250, "different text"); Assert.False(response1.Equals(response2)); Assert.False(response1.Equals((object)response2)); Assert.NotEqual(response1.GetHashCode(), response2.GetHashCode()); }
public void Equals_is_true_when_everything_matches() { var response1 = new SmtpResponse(250, "same", new[] { "line" }); var response2 = new SmtpResponse(250, "same", new[] { "line" }); Assert.True(response1.Equals(response2)); Assert.True(response1.Equals((object)response2)); Assert.Equal(response1.GetHashCode(), response2.GetHashCode()); }
public void ToString_MultiLineMessage() { SmtpResponse r = new SmtpResponse(200, "Multi line message line 1\r\n" + "Multi line message line 2\r\n" + "Multi line message line 3"); Assert.Equal("200-Multi line message line 1\r\n" + "200-Multi line message line 2\r\n" + "200 Multi line message line 3\r\n", r.ToString()); }
public void Equals_is_false_ResponseCode_doesnt_match() { var response1 = new SmtpResponse(250, ""); var response2 = new SmtpResponse(251, ""); Assert.False(response1.Equals(response2)); Assert.False(response1.Equals((object)response2)); Assert.NotEqual(response1.GetHashCode(), response2.GetHashCode()); }
public void CloneAndChange_with_ResponseText_should_change_response_text() { var response = new SmtpResponse(250, "old text", new[] { "additional" }); var cloned = response.CloneAndChange("new text"); Assert.Equal("new text", cloned.ResponseText); var clonedBack = cloned.CloneAndChange("old text"); Assert.Equal(response, clonedBack); }
private SmtpResponse VerifyEhlo() { var smtpCapabilities = _getSmtpCapabilities.GetCapabilities().ToList(); if (!smtpCapabilities.Any()) return SmtpResponses.OK; var additionalLines = smtpCapabilities.Skip(1).Select(capability => "250-" + capability).ToList(); var response = new SmtpResponse(250, smtpCapabilities.First().ToString(), additionalLines); return response; }
public void RunCommand(string command, SmtpResponse expectedSmtpResponse) { _writer.WriteLine(command); var line = _reader.ReadLine(); if (line == null) throw new InvalidOperationException("Stream has unexpectedly closed"); if (line != expectedSmtpResponse.ToString()) throw new InvalidOperationException(String.Format("After command '{0}' received '{1}' but expected '{2}'", command, line, expectedSmtpResponse)); }
private static bool IsLineTooLong(byte[] lineBuf, out SmtpResponse smtpResponse) { if (lineBuf.Length > 2040) { smtpResponse = SmtpResponses.LineTooLong; return true; } smtpResponse = SmtpResponses.None; return false; }
private static SmtpSessionInfoResponder CreateParseResponderWithMockedIRespondToSmtpData(SmtpResponse testResponse) { var respondToSmtpData = MockIRespondToSmtpDataToReturnResponse(testResponse); var factory = new DefaultSmtpResponderFactory<ISmtpServerConfiguration>(new SmtpServerConfiguration()) { DataResponder = respondToSmtpData }; var parseResponder = RecipientMailFromIdentifiedParseResponder(factory); return parseResponder; }
// I was seeing my SMTP server hang waiting for a response to the QUIT, so I added // this timeout. Pass -1 to wait forever. Timeout is in milliseconds. private bool Check_Response(Socket s, SmtpResponse response_expected, int timeout) { string sResponse; int response; byte[] bytes = new byte[1024]; int start = Environment.TickCount; while (s.Available == 0) { System.Threading.Thread.Sleep(101); if (timeout != -1) { if ((Environment.TickCount - start) > timeout) { // We timed out return false; } } } s.Receive(bytes, 0, s.Available, SocketFlags.None); sResponse = Encoding.ASCII.GetString(bytes); if (sw != null) sw.WriteLine(">>{0}", sResponse); response = Convert.ToInt32(sResponse.Substring(0, 3)); if (response != (int)response_expected) return false; return true; }
private static void LogResponse(SmtpResponse response) { var logger = MailServerLogger.Instance; if (logger.LogLevel < MailServerLogLevel.Debug) return; var logMessage = new StringBuilder(); foreach (var additionalLine in response.AdditionalLines) { logMessage.AppendLine(">>> " + additionalLine); } logMessage.AppendLine(">>> " + response.ResponseCode + " " + response.ResponseText); logger.Debug(logMessage.ToString()); }
private static IRespondToSmtpRecipientTo MockIRespondToRecipientToToReturnResponse(SmtpResponse testResponse) { var mockedInterface = new Mock<IRespondToSmtpRecipientTo>(); mockedInterface .Setup(x => x.VerifyRecipientTo(It.IsAny<SmtpSessionInfo>(), It.IsAny<MailAddressWithParameters>())) .Returns<SmtpSessionInfo, MailAddressWithParameters>((sessionInfo, mailAddressWithParameters) => testResponse); return mockedInterface.Object; }
private bool IsError (SmtpResponse status) { return ((int) status.StatusCode) >= 400; }
void ThrowIfError (SmtpResponse status) { if (IsError (status)) throw new SmtpException (status.StatusCode, status.Description); }
private static async Task SendResponseAsync(SmtpConnection connection, SmtpResponse response) { LogResponse(response); try { foreach (var additional in response.AdditionalLines) await connection.WriteLineAsyncAndFireEvents(additional); await connection.WriteLineAsyncAndFireEvents(response.ResponseCode + " " + response.ResponseText); } catch(Exception ex) { MailServerLogger.Instance.Error(ex); } }
public void AdditionalLines_should_never_be_null() { var response = new SmtpResponse(250, ""); Assert.NotNull(response.AdditionalLines); }
private bool ProcessRawLineHasResponse(string line, out SmtpResponse smtpResponse) { smtpResponse = ProcessRawLine(line); return (smtpResponse != SmtpResponses.None); }
private static IRespondToSmtpData MockIRespondToSmtpDataToReturnResponse(SmtpResponse testResponse) { var mockedInterface = new Mock<IRespondToSmtpData>(); mockedInterface .Setup(x => x.DataLine(It.IsAny<SmtpSessionInfo>(), It.IsAny<byte[]>())) .Returns<SmtpSessionInfo, byte[]>((sessionInfo, line) => testResponse); mockedInterface .Setup(x => x.DataStart(It.IsAny<SmtpSessionInfo>())) .Returns<SmtpSessionInfo>(sessionInfo => testResponse); mockedInterface .Setup(x => x.DataEnd(It.IsAny<SmtpSessionInfo>())) .Returns<SmtpSessionInfo>(sessionInfo => testResponse); return mockedInterface.Object; }
private static IRespondToSmtpIdentification MockIRespondToSmtpIdentificationToReturnResponse(SmtpResponse testResponse) { var mockedInterface = new Mock<IRespondToSmtpIdentification>(); mockedInterface .Setup(x => x.VerifyIdentification(It.IsAny<SmtpSessionInfo>(), It.IsAny<SmtpIdentification>())) .Returns<SmtpSessionInfo, SmtpIdentification>((sessionInfo, identification) => testResponse); return mockedInterface.Object; }
private static IRespondToSmtpVerify MockIRespondToVerifyToReturnResponse(SmtpResponse testResponse) { var mockedInterface = new Mock<IRespondToSmtpVerify>(); mockedInterface .Setup(x => x.Verify(It.IsAny<SmtpSessionInfo>(), It.IsAny<string>())) .Returns<SmtpSessionInfo, string>((sessionInfo, args) => testResponse); return mockedInterface.Object; }
/// <summary> /// Execute the SMTP request returning a response. This method models the state transition table for the SMTP server. /// </summary> /// <returns>Reponse to the request</returns> public virtual SmtpResponse Execute() { SmtpResponse response = null; if (action.Stateless) { if (SmtpActionType.EXPN == action || SmtpActionType.VRFY == action) { response = new SmtpResponse(252, "Not supported", this.state); } else if (SmtpActionType.HELP == action) { response = new SmtpResponse(211, "No help available", this.state); } else if (SmtpActionType.NOOP == action) { response = new SmtpResponse(250, "OK", this.state); } else if (SmtpActionType.VRFY == action) { response = new SmtpResponse(252, "Not supported", this.state); } else if (SmtpActionType.RSET == action) { response = new SmtpResponse(250, "OK", SmtpState.GREET); } else { response = new SmtpResponse(500, "Command not recognized", this.state); } } else { // Stateful commands if (SmtpActionType.CONNECT == action) { if (SmtpState.CONNECT == state) { response = new SmtpResponse(220, "localhost nDumbster SMTP service ready", SmtpState.GREET); } else { response = new SmtpResponse(503, "Bad sequence of commands: " + action, this.state); } } else if (SmtpActionType.EHLO == action) { if (SmtpState.GREET == state) { response = new SmtpResponse(250, "OK", SmtpState.MAIL); } else { response = new SmtpResponse(503, "Bad sequence of commands: " + action, this.state); } } else if (SmtpActionType.MAIL == action) { if (SmtpState.MAIL == state || SmtpState.QUIT == state) { response = new SmtpResponse(250, "OK", SmtpState.RCPT); } else { response = new SmtpResponse(503, "Bad sequence of commands: " + action, this.state); } } else if (SmtpActionType.RCPT == action) { if (SmtpState.RCPT == state) { response = new SmtpResponse(250, "OK", this.state); } else { response = new SmtpResponse(503, "Bad sequence of commands: " + action, this.state); } } else if (SmtpActionType.DATA == action) { if (SmtpState.RCPT == state) { response = new SmtpResponse(354, "Start mail input; end with <CRLF>.<CRLF>", SmtpState.DATA_HDR); } else { response = new SmtpResponse(503, "Bad sequence of commands: " + action, this.state); } } else if (SmtpActionType.UNRECOG == action) { if (SmtpState.DATA_HDR == state || SmtpState.DATA_BODY == state) { response = new SmtpResponse(-1, "", this.state); } else { response = new SmtpResponse(500, "Command not recognized", this.state); } } else if (SmtpActionType.DATA_END == action) { if (SmtpState.DATA_HDR == state || SmtpState.DATA_BODY == state) { response = new SmtpResponse(250, "OK", SmtpState.QUIT); } else { response = new SmtpResponse(503, "Bad sequence of commands: " + action, this.state); } } else if (SmtpActionType.BLANK_LINE == action) { if (SmtpState.DATA_HDR == state) { response = new SmtpResponse(-1, "", SmtpState.DATA_BODY); } else if (SmtpState.DATA_BODY == state) { response = new SmtpResponse(-1, "", this.state); } else { response = new SmtpResponse(503, "Bad sequence of commands: " + action, this.state); } } else if (SmtpActionType.QUIT == action) { if (SmtpState.QUIT == state) { response = new SmtpResponse(221, "localhost nDumbster service closing transmission channel", SmtpState.CONNECT); } else { response = new SmtpResponse(503, "Bad sequence of commands: " + action, this.state); } } else { response = new SmtpResponse(500, "Command not recognized", this.state); } } return response; }
void CheckStatus (SmtpResponse status, int i) { if (((int) status.StatusCode) != i) throw new SmtpException (status.StatusCode, status.Description); }
private static async Task SendResponseAsync(SmtpConnection connection, SmtpResponse response) { LogResponse(response); foreach (var additional in response.AdditionalLines) await connection.WriteLineAsyncAndFireEvents(additional); await connection.WriteLineAsyncAndFireEvents(response.ResponseCode + " " + response.ResponseText); }
public static SmtpResponse Parse (string line) { SmtpResponse response = new SmtpResponse (); if (line.Length < 4) throw new SmtpException ("Response is to short " + line.Length + "."); if ((line [3] != ' ') && (line [3] != '-')) throw new SmtpException ("Response format is wrong.(" + line + ")"); // parse the response code response.StatusCode = (SmtpStatusCode) Int32.Parse (line.Substring (0, 3)); // set the raw response response.Description = line; return response; }
public void Equals_is_false_Additional_missing_in_other_response() { var response1 = new SmtpResponse(250, "", new[] { "line" }); var response2 = new SmtpResponse(250, ""); Assert.False(response1.Equals(response2)); Assert.False(response1.Equals((object)response2)); }
private static SmtpSessionInfoResponder CreateParseResponderWithMockedIRespondToVerify(SmtpResponse testResponse) { var respondToVerify = MockIRespondToVerifyToReturnResponse(testResponse); var factory = new DefaultSmtpResponderFactory<ISmtpServerConfiguration>(new SmtpServerConfiguration()) { VerifyResponder = respondToVerify }; var parseResponder = MailFromIdentifiedParseResponder(factory); return parseResponder; }
private static SmtpSessionInfoResponder CreateParseResponderWithMockedIRespondToSmtpIdentification(SmtpResponse testResponse) { var respondToSmtpIdentification = MockIRespondToSmtpIdentificationToReturnResponse(testResponse); var factory = new DefaultSmtpResponderFactory<ISmtpServerConfiguration>(new SmtpServerConfiguration()) { IdentificationResponder = respondToSmtpIdentification }; var parseResponder = DefaultResponder(factory); return parseResponder; }