//-------------------------------------------------------------------------------------------
private string LookupA(string recordname, string sectiontext)
{
Dns_Client dc = new LumiSoft.Net.Dns.Client.Dns_Client();
DnsServerResponse dsr = null;
try
{
dsr = dc.Query(recordname, LumiSoft.Net.Dns.Client.QTYPE.A);
}
catch (Exception ex)
{
throw new Exception("DNS A record query for " + recordname + " failed.", ex);
}
DNS_rr_A[] records = dsr.GetARecords();
string response = sectiontext;
if (records.Length < 1)
{
fail = true;
}
for (int i = 0; i < records.Length; i++)
{
response += (i + 1) + ". ";
response += records[i].IP + " with a TTL of " + records[i].TTL + "<br>";
response += CheckPort(records[i].IP.ToString(), 5222);
response += CheckPort(records[i].IP.ToString(), 5223);
response += CheckPort(records[i].IP.ToString(), 5269);
response += CheckPort(records[i].IP.ToString(), 5270);
}
return(response);
}
public bool IsValidMXRecord(string _domain)
{
try
{
Dns_Client.DnsServers = new string[] { "8.8.8.8" };
Dns_Client.UseDnsCache = true;
using (Dns_Client dns = new Dns_Client())
{
DnsServerResponse reponse = null;
reponse = dns.Query(_domain, LumiSoft.Net.DNS.DNS_QType.MX);
if (((LumiSoft.Net.DNS.DNS_rr_MX)reponse.Answers[0]).Host != null)
{
return(true);
}
else
{
return(false);
}
}
}
catch (Exception ex)
{
return(false);
}
}
/// <summary>
/// Gets specified email domain SMTP hosts. Values are in descending priority order.
/// </summary>
/// <param name="domain">Domain name. This value can be email address too, then domain parsed automatically.</param>
/// <returns>Returns specified email domain SMTP hosts.</returns>
/// <exception cref="ArgumentNullException">Is raised when <b>domain</b> is null.</exception>
/// <exception cref="ArgumentException">Is raised when any of the arguments has invalid value.</exception>
/// <exception cref="DNS_ClientException">Is raised when DNS query failure.</exception>
private string[] GetDomainHosts(string domain)
{
if (domain == null)
{
throw new ArgumentNullException("domain");
}
if (string.IsNullOrEmpty(domain))
{
throw new ArgumentException("Invalid argument 'domain' value, you need to specify domain value.");
}
// We have email address, parse domain.
if (domain.IndexOf("@") > -1)
{
domain = domain.Substring(domain.IndexOf('@') + 1);
}
List <string> retVal = new List <string>();
// Get MX records.
DnsServerResponse response = m_pServer.DnsClient.Query(domain, QTYPE.MX);
if (response.ResponseCode == RCODE.NO_ERROR)
{
foreach (DNS_rr_MX mx in response.GetMXRecords())
{
// Block invalid MX records.
if (!string.IsNullOrEmpty(mx.Host))
{
retVal.Add(mx.Host);
}
}
}
else
{
throw new DNS_ClientException(response.ResponseCode);
}
/* RFC 2821 5.
* If no MX records are found, but an A RR is found, the A RR is treated as if it
* was associated with an implicit MX RR, with a preference of 0, pointing to that host.
*/
if (retVal.Count == 0)
{
retVal.Add(domain);
}
return(retVal.ToArray());
}
private String Find_MX_records(String pDomainName)
{
String dnsServer = "8.8.8.8"; //let's use Mr. Google.
DnsEx.DnsServers = new string[] { dnsServer };
DnsEx dns = new DnsEx();
DnsServerResponse response = null;
String hostname = pDomainName;
try
{
response = dns.Query(hostname, QTYPE.MX);
}
catch (Exception ex)
{
//throw new Exception("Network: Failed due to network connectivity of DNS to 8.8.8.8" + ex.ToString());
return("DNS queries to 8.8.8.8 are not allowed");
}
StringBuilder sb = new StringBuilder();
foreach (object rec in response.Answers)
{
if (rec is NS_Record)
{
sb.Append(((NS_Record)rec).NameServer + "\n");
}
else if (rec is CNAME_Record)
{
sb.Append(((CNAME_Record)rec).Alias + "\n");
}
else if (rec is MX_Record)
{
sb.Append(((MX_Record)rec).Host + " ");
sb.Append("(Preference: " + ((MX_Record)rec).Preference.ToString() + ") \n");
}
}
if (sb.ToString() == "")
{
return("No MX records.");
}
else
{
return(sb.ToString());
}
}
//-------------------------------------------------------------------------------------------
private string LookupSRV(string recordname, string domain, string sectiontext)
{
recordname += domain;
Dns_Client dc = new LumiSoft.Net.Dns.Client.Dns_Client();
DnsServerResponse dsr = null;
try
{
dsr = dc.Query(recordname, LumiSoft.Net.Dns.Client.QTYPE.SRV);
}
catch (Exception ex)
{
return("<span style='color:red'>DNS SRV record query for " + recordname + domain + " timed out.</span>");
}
DNS_rr_SRV[] records = dsr.GetSRVRecords();
string response = sectiontext;
if (records.Length < 1)
{
fail = true;
}
for (int i = 0; i < records.Length; i++)
{
DnsServerResponse dsr2;
try
{
dsr2 = dc.Query(records[i].Target, QTYPE.A);
}
catch (Exception ex)
{
throw new Exception("DNS sub A record query for " + domain + " failed.", ex);
}
DNS_rr_A[] aRecs = dsr2.GetARecords();
response += (i + 1) + ". ";
response += records[i].Target + " on port " + records[i].Port + " with a TTL of " + records[i].TTL + " and a priority of " + records[i].Priority + "<br />";
for (int x = 0; x < aRecs.Length; x++)
{
response += " ----> Resolves to " + aRecs[x].IP + "<br />";
response += CheckPort(aRecs[x].IP, records[i].Port);
response += CheckPort(aRecs[x].IP, 5223);
}
}
return(response);
}
//---- SMTP implementation ----//
#region function SendMessageToServer
private bool SendMessageToServer(string[] to, string reverse_path, Stream message)
{
// Get email from to string
for (int i = 0; i < to.Length; i++)
{
to[i] = (new LumiSoft.Net.Mime.Parser.eAddress(to[i])).Email;
}
ArrayList defectiveEmails = new ArrayList();
Socket so = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
BufferedSocket socket = new BufferedSocket(so);
SocketLogger logger = null;
if (m_LogCmds && this.SessionLog != null)
{
logger = new SocketLogger(so, this.SessionLog);
logger.SessionID = socket.GetHashCode().ToString();
socket.Logger = logger;
}
try{
string reply = "";
bool supports_SIZE = false;
bool supports_8BIT = false;
bool supports_BDAT = false;
#region connect to server
if (m_UseSmartHost)
{
socket.Connect(new IPEndPoint(System.Net.Dns.Resolve(m_SmartHost).AddressList[0], m_Port));
}
else
{
//---- Parse e-domain -------------------------------//
string domain = to[0];
// eg. Ivx <*****@*****.**>
if (domain.IndexOf("<") > -1 && domain.IndexOf(">") > -1)
{
domain = domain.Substring(domain.IndexOf("<") + 1, domain.IndexOf(">") - domain.IndexOf("<") - 1);
}
if (domain.IndexOf("@") > -1)
{
domain = domain.Substring(domain.LastIndexOf("@") + 1);
}
if (domain.Trim().Length == 0)
{
if (logger != null)
{
logger.AddTextEntry("Destination address '" + to[0] + "' is invalid, aborting !");
}
return(false);
}
//System.Net.Dns.
//--- Get MX record -------------------------------------------//
DnsEx dns = new DnsEx();
DnsEx.DnsServers = m_DnsServers;
DnsServerResponse dnsResponse = dns.Query(domain, QTYPE.MX);
switch (dnsResponse.ResponseCode)
{
case RCODE.NO_ERROR:
MX_Record[] mxRecords = dnsResponse.GetMXRecords();
// Try all available hosts by MX preference order, if can't connect specified host.
foreach (MX_Record mx in mxRecords)
{
try{
if (logger != null)
{
logger.AddTextEntry("Connecting with mx record to: " + mx.Host);
}
socket.Connect(new IPEndPoint(System.Net.Dns.Resolve(mx.Host).AddressList[0], m_Port));
break;
}
catch { // Just skip and let for to try next host.
if (logger != null)
{
logger.AddTextEntry("Failed connect to: " + mx.Host);
}
}
}
/* Rfc 2821 5
* If no MX records are found, but an A RR is found, the A RR is treated as
* if it was associated with an implicit MX RR, with a preference of 0,
* pointing to that host.
*
*/
if (mxRecords.Length == 0)
{
// Try to connect with A record
IPHostEntry ipEntry = null;
try{
if (logger != null)
{
logger.AddTextEntry("No mx record, trying to get A record for: " + domain);
}
ipEntry = System.Net.Dns.Resolve(domain);
}
catch {
if (logger != null)
{
logger.AddTextEntry("Invalid domain,no MX or A record: " + domain);
}
OnError(SMTP_ErrorType.InvalidEmailAddress, to, "email domain <" + domain + "> is invalid");
defectiveEmails.AddRange(to);
if (logger != null)
{
logger.Flush();
}
return(false);
}
try{
if (logger != null)
{
logger.AddTextEntry("Connecting with A record to:" + domain);
}
socket.Connect(new IPEndPoint(ipEntry.AddressList[0], m_Port));
}
catch {
if (logger != null)
{
logger.AddTextEntry("Failed connect to:" + domain);
}
}
}
break;
case RCODE.NAME_ERROR:
if (logger != null)
{
logger.AddTextEntry("Invalid domain,no MX or A record: " + domain);
}
OnError(SMTP_ErrorType.InvalidEmailAddress, to, "email domain <" + domain + "> is invalid");
defectiveEmails.AddRange(to);
if (logger != null)
{
logger.Flush();
}
return(false);
case RCODE.SERVER_FAILURE:
if (logger != null)
{
logger.AddTextEntry("Dns server unvailable.");
}
OnError(SMTP_ErrorType.UnKnown, to, "Dns server unvailable.");
defectiveEmails.AddRange(to);
if (logger != null)
{
logger.Flush();
}
return(false);
}
}
if (!socket.Connected)
{
OnError(SMTP_ErrorType.UnKnown, to, "Unable connect to server !");
if (logger != null)
{
logger.Flush();
}
return(false);
}
#endregion
#region Get 220 reply from server
/* NOTE: reply may be multiline
* 220 xx ready
* or
* 220-someBull
* 200 xx
*/
// Server must reply 220 - Server OK
reply = socket.ReadLine();
if (!IsReplyCode("220", reply))
{
OnError(SMTP_ErrorType.UnKnown, to, reply);
socket.SendLine("QUIT");
if (logger != null)
{
logger.Flush();
}
return(false);
}
else
{
// 220-xxx<CRLF>
// 220 aa<CRLF> - means end
// reply isn't complete, get more
while (reply.IndexOf("220 ") == -1)
{
reply += socket.ReadLine();
}
}
#endregion
#region cmd EHLO/HELO
// Send greeting to server
socket.SendLine("EHLO " + m_HostName);
reply = socket.ReadLine();
if (!IsReplyCode("250", reply))
{
// EHLO failed, mayby server doesn't support it, try HELO
socket.SendLine("HELO " + m_HostName);
reply = socket.ReadLine();
if (!IsReplyCode("250", reply))
{
OnError(SMTP_ErrorType.UnKnown, to, reply);
socket.SendLine("QUIT");
defectiveEmails.AddRange(to);
if (logger != null)
{
logger.Flush();
}
return(false);
}
// else{
// supports_ESMTP = false;
// }
}
else
{
// 250-xxx<CRLF>
// 250 aa<CRLF> - means end
// reply isn't complete, get more
while (reply.IndexOf("250 ") == -1)
{
reply += socket.ReadLine();
}
// Check if SIZE argument is supported
if (reply.ToUpper().IndexOf("SIZE") > -1)
{
supports_SIZE = true;
}
// Check if 8BITMIME argument is supported
if (reply.ToUpper().IndexOf("8BITMIME") > -1)
{
supports_8BIT = true;
}
// Check if CHUNKING argument is supported
if (reply.ToUpper().IndexOf("CHUNKING") > -1)
{
supports_BDAT = true;
}
}
#endregion
// If server doesn't support 8bit mime, check if message is 8bit.
// If is we MAY NOT send this message or loss of data
/* if(!supports_8BIT){
* if(Is8BitMime(message)){
* OnError(SMTP_ErrorType.NotSupported,to,"Message is 8-Bit mime and server doesn't support it.");
* socket.SendLine("QUIT");
*
* if(logger != null){
* logger.Flush();
* }
* return false;
* }
* }*/
#region cmd AUTH
if (this.m_Username != null && m_Username.Length > 0 && m_Password != null && m_Password.Length > 0)
{
if (reply.ToUpper().IndexOf("AUTH") > -1)
{
if (reply.ToUpper().IndexOf("LOGIN") > -1)
{
socket.SendLine("AUTH LOGIN");
reply = socket.ReadLine();
if (!IsReplyCode("334", reply))
{
OnError(SMTP_ErrorType.NotAuthenticated, to, "Failed to authenticate");
socket.SendLine("QUIT");
if (logger != null)
{
logger.Flush();
}
return(false);
}
socket.SendLine(Convert.ToBase64String(System.Text.Encoding.ASCII.GetBytes(m_Username.ToCharArray())));
reply = socket.ReadLine();
if (!IsReplyCode("334", reply))
{
OnError(SMTP_ErrorType.NotAuthenticated, to, "Failed to authenticate");
socket.SendLine("QUIT");
if (logger != null)
{
logger.Flush();
}
return(false);
}
socket.SendLine(Convert.ToBase64String(System.Text.Encoding.ASCII.GetBytes(m_Password.ToCharArray())));
reply = socket.ReadLine();
if (!IsReplyCode("235", reply))
{
OnError(SMTP_ErrorType.NotAuthenticated, to, "Failed to authenticate");
socket.SendLine("QUIT");
if (logger != null)
{
logger.Flush();
}
return(false);
}
}
// if(reply.ToUpper().IndexOf("CRAM-MD5") > -1)
// {
// socket.SendLine("AUTH CRAM-MD5");
// reply = socket.ReadLine();
// if (IsReplyCode("334",auth))
// {
// socket.SendLine(Convert.ToBase64String(Encoding.ASCII.GetBytes(m_Username.ToCharArray())));
// socket.SendLine(Convert.ToBase64String(Encoding.ASCII.GetBytes(m_Password.ToCharArray())));
// }
// }
}
else
{
//server did not support AUTH
}
}
#endregion
#region cmd MAIL
// NOTE: Syntax:{MAIL FROM:<*****@*****.**> [SIZE=msgSize]<CRLF>}
// Send Mail From
if (supports_SIZE)
{
socket.SendLine("MAIL FROM:<" + reverse_path + "> SIZE=" + (message.Length - message.Position));
}
else
{
socket.SendLine("MAIL FROM:<" + reverse_path + ">");
}
reply = socket.ReadLine();
if (!IsReplyCode("250", reply))
{
// To Do: Check if size exceeded error:
OnError(SMTP_ErrorType.UnKnown, to, reply);
socket.SendLine("QUIT");
defectiveEmails.AddRange(to);
if (logger != null)
{
logger.Flush();
}
return(false);
}
#endregion
#region cmd RCPT
// NOTE: Syntax:{RCPT TO:<*****@*****.**><CRLF>}
bool isAnyValidEmail = false;
foreach (string rcpt in to)
{
// Send Mail To
socket.SendLine("RCPT TO:<" + rcpt + ">");
reply = socket.ReadLine();
if (!IsReplyCode("250", reply))
{
// Is unknown user
if (IsReplyCode("550", reply))
{
OnError(SMTP_ErrorType.InvalidEmailAddress, new string[] { rcpt }, reply);
}
else
{
OnError(SMTP_ErrorType.UnKnown, new string[] { rcpt }, reply);
}
defectiveEmails.Add(rcpt);
}
else
{
isAnyValidEmail = true;
}
}
// If there isn't any valid email - quit.
if (!isAnyValidEmail)
{
socket.SendLine("QUIT");
if (logger != null)
{
logger.Flush();
}
return(false);
}
//---------------------------------------------//
#endregion
#region cmd DATA
if (!supports_BDAT)
{
// Notify Data Start
socket.SendLine("DATA");
reply = socket.ReadLine();
if (!IsReplyCode("354", reply))
{
OnError(SMTP_ErrorType.UnKnown, to, reply);
socket.SendLine("QUIT");
defectiveEmails.AddRange(to);
if (logger != null)
{
logger.Flush();
}
return(false);
}
//------- Do period handling -----------------------------------------//
// If line starts with '.', add additional '.'.(Read rfc for more info)
MemoryStream msgStrmPeriodOk = Core.DoPeriodHandling(message, true, false);
//--------------------------------------------------------------------//
// Check if message ends with <CRLF>, if not add it. -------//
if (msgStrmPeriodOk.Length >= 2)
{
byte[] byteEnd = new byte[2];
msgStrmPeriodOk.Position = msgStrmPeriodOk.Length - 2;
msgStrmPeriodOk.Read(byteEnd, 0, 2);
if (byteEnd[0] != (byte)'\r' && byteEnd[1] != (byte)'\n')
{
msgStrmPeriodOk.Write(new byte[] { (byte)'\r', (byte)'\n' }, 0, 2);
}
}
msgStrmPeriodOk.Position = 0;
//-----------------------------------------------------------//
//---- Send message --------------------------------------------//
long totalSent = 0;
long totalLength = msgStrmPeriodOk.Length;
while (totalSent < totalLength)
{
byte[] dataBuf = new byte[4000];
int nCount = msgStrmPeriodOk.Read(dataBuf, 0, dataBuf.Length);
int countSended = socket.Send(dataBuf, 0, nCount, SocketFlags.None);
totalSent += countSended;
if (countSended != nCount)
{
msgStrmPeriodOk.Position = totalSent;
}
OnPartOfMessageIsSent(countSended, totalSent, totalLength);
}
//-------------------------------------------------------------//
msgStrmPeriodOk.Close();
// Notify End of Data
socket.SendLine(".");
reply = socket.ReadLine();
if (!IsReplyCode("250", reply))
{
OnError(SMTP_ErrorType.UnKnown, to, reply);
socket.SendLine("QUIT");
defectiveEmails.AddRange(to);
if (logger != null)
{
logger.Flush();
}
return(false);
}
}
#endregion
#region cmd BDAT
if (supports_BDAT)
{
socket.SendLine("BDAT " + (message.Length - message.Position) + " LAST");
//---- Send message --------------------------------------------//
long totalSent = 0;
long totalLength = message.Length - message.Position;
while (totalSent < totalLength)
{
byte[] dataBuf = new byte[4000];
int nCount = message.Read(dataBuf, 0, dataBuf.Length);
int countSended = socket.Send(dataBuf, 0, nCount, SocketFlags.None);
totalSent += countSended;
if (countSended != nCount)
{
message.Position = totalSent;
}
OnPartOfMessageIsSent(countSended, totalSent, totalLength);
}
//-------------------------------------------------------------//
// Get store result
reply = socket.ReadLine();
if (!reply.StartsWith("250"))
{
OnError(SMTP_ErrorType.UnKnown, to, reply);
socket.SendLine("QUIT");
defectiveEmails.AddRange(to);
if (logger != null)
{
logger.Flush();
}
return(false);
}
}
#endregion
#region cmd QUIT
// Notify server - server can exit now
socket.SendLine("QUIT");
// reply = socket.ReadLine();
#endregion
}
catch (Exception x) {
OnError(SMTP_ErrorType.UnKnown, to, x.Message);
defectiveEmails.AddRange(to);
if (logger != null)
{
logger.Flush();
}
return(false);
}
//finally{
// Raise event
//OnSendJobCompleted(Thread.CurrentThread.GetHashCode().ToString(),to,defectiveEmails);
OnSendJobCompleted(Thread.CurrentThread.Name, to, defectiveEmails);
//}
if (logger != null)
{
logger.Flush();
}
return(true);
}
/// <summary>
/// Filters sender.
/// </summary>
/// <param name="from">Sender.</param>
/// <param name="api">Reference to server API.</param>
/// <param name="session">Reference to SMTP session.</param>
/// <param name="errorText">Filtering error text what is returned to client. ASCII text, 100 chars maximum.</param>
/// <returns>Returns true if sender is ok or false if rejected.</returns>
public bool Filter(string from, IMailServerApi api, SMTP_Session session, out string errorText)
{
errorText = null;
bool ok = true;
// Don't check authenticated users or LAN IP
if (session.IsAuthenticated || IsPrivateIP(session.RemoteEndPoint.Address))
{
return(true);
}
try{
//--- Load data -----------------------
DataSet ds = new DataSet();
ds.Tables.Add("General");
ds.Tables["General"].Columns.Add("CheckHelo");
ds.Tables["General"].Columns.Add("LogRejections");
ds.Tables.Add("BlackListSettings");
ds.Tables["BlackListSettings"].Columns.Add("ErrorText");
ds.Tables.Add("BlackList");
ds.Tables["BlackList"].Columns.Add("IP");
ds.Tables.Add("Servers");
ds.Tables["Servers"].Columns.Add("Cost");
ds.Tables["Servers"].Columns.Add("Server");
ds.Tables["Servers"].Columns.Add("DefaultRejectionText");
ds.ReadXml(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + "\\lsDNSBL_Filter_db.xml");
bool logRejections = false;
#region General
if (ds.Tables["General"].Rows.Count == 1)
{
if (Convert.ToBoolean(ds.Tables["General"].Rows[0]["CheckHelo"]))
{
DnsServerResponse response = Dns_Client.Static.Query(session.EhloHost, DNS_QType.A);
// If dns server connection errors, don't block.
if (response.ConnectionOk && response.ResponseCode != DNS_RCode.SERVER_FAILURE)
{
bool found = false;
foreach (DNS_rr_A a in response.GetARecords())
{
if (session.RemoteEndPoint.Address.Equals(a.IP))
{
found = true;
break;
}
}
if (!found)
{
errorText = "Not valid DNS EHLO/HELO name for your IP '" + session.EhloHost + "' !";
return(false);
}
}
}
logRejections = ConvertEx.ToBoolean(ds.Tables["General"].Rows[0]["LogRejections"]);
}
#endregion
#region Balck List
foreach (DataRow dr in ds.Tables["BlackList"].Rows)
{
if (IsAstericMatch(dr["IP"].ToString(), session.RemoteEndPoint.Address.ToString()))
{
errorText = ds.Tables["BlackListSettings"].Rows[0]["ErrorText"].ToString();
return(false);
}
}
#endregion
#region DNSBL
foreach (DataRow dr in ds.Tables["Servers"].Rows)
{
DnsServerResponse dnsResponse = Dns_Client.Static.Query(ReverseIP(session.RemoteEndPoint.Address) + "." + dr["Server"].ToString(), DNS_QType.ANY);
DNS_rr_A[] recs = dnsResponse.GetARecords();
if (recs.Length > 0)
{
if (logRejections)
{
WriteFilterLog("Sender:" + from + " IP:" + session.RemoteEndPoint.Address.ToString() + " blocked\r\n");
}
errorText = dr["DefaultRejectionText"].ToString();
// Server provided return text, use it
if (dnsResponse.GetTXTRecords().Length > 0)
{
errorText = dnsResponse.GetTXTRecords()[0].Text;
}
if (errorText == "")
{
errorText = "You are in '" + dr["Server"].ToString() + "' rejection list !";
}
return(false);
}
}
#endregion
}
catch {
}
return(ok);
}
public bool Filter(string from, IMailServerManagementApi api, SMTP_Session session, out string errorText)
{
errorText = null;
bool result = true;
if (session.IsAuthenticated || this.IsPrivateIP(session.RemoteEndPoint.Address))
{
return(true);
}
try
{
DataSet dataSet = new DataSet();
dataSet.Tables.Add("General");
dataSet.Tables["General"].Columns.Add("CheckHelo");
dataSet.Tables["General"].Columns.Add("LogRejections");
dataSet.Tables.Add("BlackListSettings");
dataSet.Tables["BlackListSettings"].Columns.Add("ErrorText");
dataSet.Tables.Add("BlackList");
dataSet.Tables["BlackList"].Columns.Add("IP");
dataSet.Tables.Add("Servers");
dataSet.Tables["Servers"].Columns.Add("Cost");
dataSet.Tables["Servers"].Columns.Add("Server");
dataSet.Tables["Servers"].Columns.Add("DefaultRejectionText");
dataSet.ReadXml(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + "\\DnsBlackList.xml");
bool flag = false;
if (dataSet.Tables["General"].Rows.Count == 1)
{
if (Convert.ToBoolean(dataSet.Tables["General"].Rows[0]["CheckHelo"]))
{
DnsServerResponse dnsServerResponse = Dns_Client.Static.Query(session.EhloHost, DNS_QType.A);
if (dnsServerResponse.ConnectionOk && dnsServerResponse.ResponseCode != DNS_RCode.SERVER_FAILURE)
{
bool flag2 = false;
DNS_rr_A[] aRecords = dnsServerResponse.GetARecords();
for (int i = 0; i < aRecords.Length; i++)
{
DNS_rr_A dNS_rr_A = aRecords[i];
if (session.RemoteEndPoint.Address.Equals(dNS_rr_A.IP))
{
flag2 = true;
break;
}
}
if (!flag2)
{
errorText = "Not valid DNS EHLO/HELO name for your IP '" + session.EhloHost + "' !";
bool result2 = false;
return(result2);
}
}
}
flag = ConvertEx.ToBoolean(dataSet.Tables["General"].Rows[0]["LogRejections"]);
}
foreach (DataRow dataRow in dataSet.Tables["BlackList"].Rows)
{
if (this.IsAstericMatch(dataRow["IP"].ToString(), session.RemoteEndPoint.Address.ToString()))
{
errorText = dataSet.Tables["BlackListSettings"].Rows[0]["ErrorText"].ToString();
bool result2 = false;
return(result2);
}
}
foreach (DataRow dataRow2 in dataSet.Tables["Servers"].Rows)
{
DnsServerResponse dnsServerResponse2 = Dns_Client.Static.Query(this.ReverseIP(session.RemoteEndPoint.Address) + "." + dataRow2["Server"].ToString(), DNS_QType.ANY);
DNS_rr_A[] aRecords2 = dnsServerResponse2.GetARecords();
if (aRecords2.Length > 0)
{
if (flag)
{
this.WriteFilterLog(string.Concat(new string[]
{
"Sender:",
from,
" IP:",
session.RemoteEndPoint.Address.ToString(),
" blocked\r\n"
}));
}
errorText = dataRow2["DefaultRejectionText"].ToString();
if (dnsServerResponse2.GetTXTRecords().Length > 0)
{
errorText = dnsServerResponse2.GetTXTRecords()[0].Text;
}
if (errorText == "")
{
errorText = "You are in '" + dataRow2["Server"].ToString() + "' rejection list !";
}
bool result2 = false;
return(result2);
}
}
}
catch
{
}
return(result);
}
