private List <string> GetHostsFromResponse(IDnsQueryResponse response)
{
var hosts = new List <string>();
foreach (var srvRecord in response.Answers.SrvRecords())
{
var h = srvRecord.Target.ToString();
if (h.EndsWith(".", StringComparison.Ordinal))
{
h = h.Substring(0, h.Length - 1);
}
hosts.Add(h + ":" + srvRecord.Port);
}
return(hosts);
}
private async Task <List <string> > GetARecords(string domain, string host)
{
List <string> ipAddresses = new List <string>();
IDnsQueryResponse response = await _lookupClient.QueryAsync(host, QueryType.A);
if (!response.HasError)
{
ipAddresses.AddRange(response.Answers
.OfType <ARecord>()
.Select(_ => _.Address.ToString().Escape())
.ToList());
}
return(ipAddresses);
}
private async Task <IDnsQueryResponse> RecursivelyFollowCnames(IDnsQueryResponse result, int attempt)
{
if (result.Answers.CnameRecords().Any())
{
var cname = result.Answers.CnameRecords().First();
var recursiveClients = await _provider.GetClients(cname.CanonicalName, attempt);
var index = attempt % recursiveClients.Count();
var recursiveClient = recursiveClients.ElementAt(index);
var txtResponse = await recursiveClient.LookupClient.QueryAsync(cname.CanonicalName, QueryType.TXT);
_log.Debug("Name server {NameServerIpAddress} selected", txtResponse.NameServer.Endpoint.Address.ToString());
return(await recursiveClient.RecursivelyFollowCnames(txtResponse, attempt));
}
return(result);
}
public Domain SetARecords(IDnsQueryResponse result)
{
if (result == null)
{
throw new ArgumentException("ARecord é nulo");
}
var record = result.Answers.ARecords().FirstOrDefault();
var address = record?.Address;
var ip = address?.ToString();
Ip = ip;
Ttl = record?.TimeToLive ?? 0;
return(this);
}
private async Task ExcecuteRun()
{
//var swatch = Stopwatch.StartNew();
while (_running)
{
var query = NextDomainName();
try
{
IDnsQueryResponse response = null;
_spinner.Message = query;
if (!_runSync)
{
response = await _lookup.QueryAsync(query, QueryType.A);
}
else
{
response = await Task.Run(() => _lookup.Query(query, QueryType.A));
}
Interlocked.Increment(ref _allExcecutions);
Interlocked.Increment(ref _reportExcecutions);
if (response.HasError)
{
_errorsPerCode.AddOrUpdate(response.Header.ResponseCode.ToString(), 1, (c, v) => v + 1);
_failByServer.AddOrUpdate(response.NameServer, 1, (n, v) => v + 1);
Interlocked.Increment(ref _errors);
}
else
{
_successByServer.AddOrUpdate(response.NameServer, 1, (n, v) => v + 1);
Interlocked.Increment(ref _success);
}
}
catch (DnsResponseException ex)
{
_errorsPerCode.AddOrUpdate(ex.Code.ToString(), 1, (c, v) => v + 1);
Interlocked.Increment(ref _errors);
}
catch (Exception ex)
{
_errorsPerCode.AddOrUpdate(ex.GetType().Name, 1, (c, v) => v + 1);
Interlocked.Increment(ref _errors);
}
}
}
public async Task <IPAddress> QueryIp(string domain, CancellationToken token)
{
IDnsQueryResponse response = await _lookup.QueryAsync(domain, QueryType.A, QueryClass.IN, token);
ARecord aRecord = response.Answers.ARecords().FirstOrDefault();
if (aRecord != null)
{
return(aRecord.Address);
}
response = await _lookup.QueryAsync(domain, QueryType.AAAA, QueryClass.IN, token);
AaaaRecord aaaaRecord = response.Answers.AaaaRecords().FirstOrDefault();
return(aaaaRecord?.Address);
}
public bool Add(string key, IDnsQueryResponse response)
{
if (key == null)
{
throw new ArgumentNullException(key);
}
if (Enabled && response != null && !response.HasError && response.Answers.Count > 0)
{
var all = response.AllRecords.Where(p => !(p is Protocol.Options.OptRecord));
if (all.Any())
{
// in millis
double minTtl = all.Min(p => p.InitialTimeToLive) * 1000d;
if (MinimumTimout == Timeout.InfiniteTimeSpan)
{
// TODO: Log warning once?
minTtl = s_maxTimeout.TotalMilliseconds;
}
else if (MinimumTimout.HasValue && minTtl < MinimumTimout.Value.TotalMilliseconds)
{
minTtl = MinimumTimout.Value.TotalMilliseconds;
}
// max ttl check which can limit the upper boundary
if (MaximumTimeout.HasValue && MaximumTimeout != Timeout.InfiniteTimeSpan && minTtl > MaximumTimeout.Value.TotalMilliseconds)
{
minTtl = MaximumTimeout.Value.TotalMilliseconds;
}
if (minTtl < 1d)
{
return(false);
}
var newEntry = new ResponseEntry(response, minTtl);
StartCleanup();
return(_cache.TryAdd(key, newEntry));
}
}
StartCleanup();
return(false);
}
private static string GetHostNameAsyncProcessResult(IDnsQueryResponse result)
{
if (result.HasError)
{
return(null);
}
var hostName = result.Answers.PtrRecords().FirstOrDefault()?.PtrDomainName;
if (string.IsNullOrWhiteSpace(hostName))
{
return(null);
}
// removing the . at the end
return(hostName.Value.Substring(0, hostName.Value.Length - 1));
}
public async Task <DnsResult <List <List <string> > > > GetSpfRecords(string domain)
{
IDnsQueryResponse response = await _lookupClient.QueryAsync(domain, QueryType.TXT);
if (response.HasError)
{
return(new DnsResult <List <List <string> > >(response.ErrorMessage));
}
return(new DnsResult <List <List <string> > >(
response.Answers
.OfType <TxtRecord>()
.Where(_ => _.Text.FirstOrDefault()?.StartsWith("v=spf", StringComparison.OrdinalIgnoreCase) ??
false)
.Select(_ => _.Text.Select(r => r.Escape()).ToList())
.ToList(), response.MessageSize));
}
private IDnsQueryResponse RecursivelyFollowCnames(IDnsQueryResponse result)
{
if (result.Answers.CnameRecords().Any())
{
var cname = result.Answers.CnameRecords().First();
var nsChecker = this;
if (_default != null)
{
nsChecker = _default;
}
var nameServerIpAddresses = nsChecker.GetNameServerIpAddresses(cname.CanonicalName);
var recursiveClient = new LookupClientWrapper(_domainParser, _log, new LookupClient(nameServerIpAddresses.ToArray()), _default);
IDnsQueryResponse txtResponse = recursiveClient.LookupClient.Query(cname.CanonicalName, QueryType.TXT);
_log.Debug("Name server {NameServerIpAddress} selected", txtResponse.NameServer.Endpoint.Address.ToString());
return(recursiveClient.RecursivelyFollowCnames(txtResponse));
}
return(result);
}
// private methods
private List <SrvRecord> GetSrvRecords(IDnsQueryResponse response)
{
var wrappedSrvRecords = response.Answers.SrvRecords().ToList();
var srvRecords = new List <SrvRecord>();
foreach (var wrappedSrvRecord in wrappedSrvRecords)
{
var host = wrappedSrvRecord.Target.ToString();
var port = wrappedSrvRecord.Port;
var endPoint = new DnsEndPoint(host, port);
var timeToLive = TimeSpan.FromSeconds(wrappedSrvRecord.InitialTimeToLive);
var srvRecord = new SrvRecord(endPoint, timeToLive);
srvRecords.Add(srvRecord);
}
return(srvRecords);
}
public static void Main(string[] args)
{
if (args.Length > 2 || args.Length == 0 || args[0] == "-h" || args[0] == "/?" || args[0] == "/h" || args[0] == "--help")
{
Console.WriteLine("WinBinReplacements: nslookup.exe <hostname> [dns_server]");
return;
}
LookupClient client = new LookupClient();
IDnsQueryResponse result = null;
NameServer ns = null;
if (args.Length == 2)
{
try
{
ns = new NameServer(IPAddress.Parse(args[1]));
client = new LookupClient(ns);
}
catch
{
Console.WriteLine("[!] Error: nameserver is not an IP address: " + args[1]);
return;
}
}
try
{
result = client.Query(args[0], QueryType.A);
}
catch (DnsResponseException)
{
Console.WriteLine("[!] Error: DNS server could not be contacted");
return;
}
foreach (var answer in result.Answers)
{
Console.WriteLine(answer);
}
if (result.Answers.Count == 0)
{
Console.WriteLine("[!] Error: no matching records found for " + args[0]);
}
}
public async Task <DnsResult <List <HostMxRecord> > > GetMxRecords(string domain)
{
_log.LogInformation($"Querying mx records for {domain}");
IDnsQueryResponse response = await _lookupClient.QueryAsync(domain, QueryType.MX);
if (response.HasError)
{
_log.LogInformation($"Error occured quering mx records for {domain}, error: {response.ErrorMessage}");
return(new DnsResult <List <HostMxRecord> >(response.ErrorMessage));
}
List <HostMxRecord> records = await GetRecords(domain, response);
_log.LogInformation($"MX records for {domain}, results: {JsonConvert.SerializeObject(records)}");
return(new DnsResult <List <HostMxRecord> >(records, response.MessageSize));
}
public async Task <TlsRptRecordInfos> GetTlsRptRecords(string domain)
{
string queryText = $"_smtp._tls.{domain}";
QueryType queryType = QueryType.TXT;
IDnsQueryResponse response = await _lookupClient.QueryAsync(queryText, queryType);
List <TlsRptRecordInfo> tlsRptRecordInfos = response.Answers.OfType <TxtRecord>()
.Where(_ => _.Text.FirstOrDefault()?.StartsWith("v=TLSRPTv", StringComparison.OrdinalIgnoreCase) ?? false)
.Select(_ => new TlsRptRecordInfo(domain, _.Text.Select(r => r.Escape()).ToList()))
.ToList();
if (response.HasError && response.ErrorMessage != NonExistentDomainError && response.ErrorMessage != SERV_FAILURE_ERROR)
{
return(new TlsRptRecordInfos(domain, new FailedPollError(response.ErrorMessage), response.MessageSize));
}
return(new TlsRptRecordInfos(domain, tlsRptRecordInfos, response.MessageSize));
}
public void AuditResponse(IDnsQueryResponse queryResponse)
{
if (queryResponse.Questions.Count > 0)
{
_auditWriter.AppendLine(";; QUESTION SECTION:");
foreach (var question in queryResponse.Questions)
{
_auditWriter.AppendLine(question.ToString(s_printOffset));
}
_auditWriter.AppendLine();
}
if (queryResponse.Answers.Count > 0)
{
_auditWriter.AppendLine(";; ANSWER SECTION:");
foreach (var answer in queryResponse.Answers)
{
_auditWriter.AppendLine(answer.ToString(s_printOffset));
}
_auditWriter.AppendLine();
}
if (queryResponse.Authorities.Count > 0)
{
_auditWriter.AppendLine(";; AUTHORITIES SECTION:");
foreach (var auth in queryResponse.Authorities)
{
_auditWriter.AppendLine(auth.ToString(s_printOffset));
}
_auditWriter.AppendLine();
}
if (queryResponse.Additionals.Count > 0)
{
_auditWriter.AppendLine(";; ADDITIONALS SECTION:");
foreach (var additional in queryResponse.Additionals)
{
_auditWriter.AppendLine(additional.ToString(s_printOffset));
}
_auditWriter.AppendLine();
}
}
private async Task <bool> CheckDnsEntriesAsync(string domain)
{
try
{
LookupClient lookup = new LookupClient
{
Timeout = TimeSpan.FromSeconds(5)
};
IDnsQueryResponse result = await lookup.QueryAsync(domain, QueryType.MX).ConfigureAwait(false);
IEnumerable <DnsClient.Protocol.DnsResourceRecord> records = result.Answers.Where(record => record.RecordType == DnsClient.Protocol.ResourceRecordType.A ||
record.RecordType == DnsClient.Protocol.ResourceRecordType.AAAA ||
record.RecordType == DnsClient.Protocol.ResourceRecordType.MX);
return(records.Any());
}
catch (DnsResponseException)
{
return(false);
}
}
public bool Add(string key, IDnsQueryResponse response)
{
if (key == null)
{
throw new ArgumentNullException(key);
}
if (Enabled && response != null && !response.HasError)
{
var all = response.AllRecords;
if (all.Any())
{
// in millis
double minTtl = all.Min(p => p.TimeToLive) * 1000d;
if (MinimumTimout == Timeout.InfiniteTimeSpan)
{
minTtl = s_maxTimeout.TotalMilliseconds;
}
else if (MinimumTimout.HasValue && minTtl < MinimumTimout.Value.TotalMilliseconds)
{
minTtl = (long)MinimumTimout.Value.TotalMilliseconds;
}
if (minTtl < 1d)
{
return(false);
}
var newEntry = new ResponseEntry(response, minTtl);
StartCleanup();
return(_cache.TryAdd(key, newEntry));
}
}
StartCleanup();
return(false);
}
public void ResolveServiceProcessResultReturnAEntityList()
{
IDnsQueryResponse result = null;
var mockResult = new Mock <IDnsQueryResponse>();
DnsString canonicalName = DnsClient.DnsString.Parse("hostname.com");
ResourceRecordInfo info = new ResourceRecordInfo(canonicalName, DnsClient.Protocol.ResourceRecordType.SRV, DnsClient.QueryClass.IN, 10, 1);
var record = new SrvRecord(info, 1, 10, 443, canonicalName);
var cNameRecord = new CNameRecord(info, canonicalName);
List <SrvRecord> answers = new List <SrvRecord>()
{
record
};
mockResult.Setup(foo => foo.Answers).Returns(answers);
mockResult.Setup(foo => foo.Additionals).Returns(new List <CNameRecord>()
{
cNameRecord
});
result = mockResult.Object;
List <DnsSrvResultEntry> ret = ResolveServiceProcessResult(result);
}
/// <summary>
/// Performs a DNS SRV lookup for the given host and returns a list of <see cref="SrvRecord"/> objects for the "xmpp-client" service.
/// </summary>
/// <param name="host">The host the lookup should be performed for.</param>
/// <returns>A list of <see cref="SrvRecord"/> objects ordered by their priority or an empty list of an error occurred or no entries were found.</returns>
public static async Task <List <SrvRecord> > DnsSrvLookupAsync(string host)
{
Logger.Info(LOGGER_TAG + "Performing DNS SRV lookup for: " + host);
LookupClient lookup = new LookupClient();
try
{
IDnsQueryResponse response = await lookup.QueryAsync("_xmpp-client._tcp." + host, QueryType.SRV);
if (response is DnsQueryResponse dnsResponse)
{
IEnumerable <SrvRecord> records = dnsResponse.AllRecords.Where((record) => record is SrvRecord).Select((record) => record as SrvRecord);
List <SrvRecord> list = records.ToList();
list.Sort((a, b) => a.Priority.CompareTo(b.Priority));
return(list);
}
}
catch (Exception e)
{
Logger.Error(LOGGER_TAG + "Failed to look up DNS SRV record for: " + host, e);
}
return(new List <SrvRecord>());
}
public CaaReponse(IDnsQueryResponse dnsReponse)
{
this._Response = dnsReponse;
}
public static void Main(string[] args)
{
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine("Server: ");
var input = Console.ReadLine();
var server = string.IsNullOrWhiteSpace(input) ? "jean-pierre-bachmann.de" : input;
Console.Title = server;
Console.WriteLine("Find TXT Record:");
input = Console.ReadLine();
input = string.IsNullOrWhiteSpace(input) ? "SpEsZQ0YgIvvSFx3Vcd6Ssli7fYW0jtmTMcL829da3o" : input;
var dnsServer = new List<DomainLookup>
{
new DomainLookup(IPAddress.Parse("8.8.8.8")),
new DomainLookup(IPAddress.Parse("208.67.222.222")),
new DomainLookup(IPAddress.Parse("208.67.222.123")),
new DomainLookup(IPAddress.Parse("209.244.0.3")),
new DomainLookup(IPAddress.Parse("216.146.35.35")),
new DomainLookup(IPAddress.Parse("195.46.39.39")),
new DomainLookup(IPAddress.Parse("8.26.56.26")),
new DomainLookup(IPAddress.Parse("84.200.69.80")),
new DomainLookup(IPAddress.Parse("81.169.163.106")),
new DomainLookup(IPAddress.Parse("81.169.148.38")),
};
var dnsDomains = new[]
{
"ns1-06.azure-dns.com",
"ns2-06.azure-dns.net",
"ns3-06.azure-dns.org",
"ns4-06.azure-dns.info",
"ns1-08.azure-dns.com",
"ns2-08.azure-dns.net",
"ns3-08.azure-dns.org",
"ns4-08.azure-dns.info",
"a.root-servers.net",
};
foreach (var dnsDomain in dnsDomains)
{
foreach (var hostAddress in Dns.GetHostAddresses(dnsDomain).Where(e => e.AddressFamily == AddressFamily.InterNetwork))
{
dnsServer.Add(new DomainLookup(hostAddress));
}
}
Console.Clear();
Console.WriteLine("Check Dns:");
var client = new LookupClient();
client.UseCache = true;
while (true)
{
foreach (var lookupClient in dnsServer)
{
if (lookupClient.ReverseLookup == null)
{
var dnsQueryResponse = client.GetHostName(lookupClient.Address);
lookupClient.ReverseLookup = dnsQueryResponse;
}
Console.Write($"Check: {lookupClient.Address} - {lookupClient.ReverseLookup}");
if (lookupClient.ErrorCounter > 10)
{
Console.WriteLine("Skipped");
}
var stopWaiter = false;
var stoppedWaiter = new ManualResetEventSlim();
Task.Run(async () =>
{
var waiterArray = new[] { '|', '/', '-', '\\', '-' };
var index = 0;
while (!stopWaiter)
{
if (index == waiterArray.Length)
{
index = 0;
}
Console.Write(waiterArray[index++]);
await Task.Delay(140);
Console.CursorLeft--;
}
stoppedWaiter.Set();
});
IDnsQueryResponse txtQuery = null;
IDnsQueryResponse nsQuery = null;
string errorText = null;
try
{
txtQuery = client.QueryServer(new[] {lookupClient.Address}, server, QueryType.TXT);
errorText = txtQuery.HasError ? txtQuery.ErrorMessage : null;
nsQuery = client.QueryServer(new[] {lookupClient.Address}, server, QueryType.NS);
errorText = txtQuery.HasError ? txtQuery.ErrorMessage : null;
}
catch (Exception e)
{
errorText = e.Message;
}
finally
{
stopWaiter = true;
stoppedWaiter.Wait();
}
Console.Write(" ");
Console.CursorLeft -= " ".Length;
if (errorText != null)
{
lookupClient.ErrorCounter++;
Console.WriteLine("...Error: " + errorText);
continue;
}
Console.WriteLine();
var txtRecords = txtQuery.Answers.TxtRecords().ToArray();
var firstOrDefault = txtRecords.FirstOrDefault(e =>
e.Text.Any(f => f.Equals(input)));
var nsRecords = nsQuery.Answers.NsRecords();
foreach (var nsRecord in nsRecords)
{
Console.ForegroundColor = ConsoleColor.Magenta;
Console.WriteLine(nsRecord );
}
if (firstOrDefault != null)
{
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("FOUND!");
}
else
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("not found: ");
foreach (var txtRecord in txtRecords)
{
Console.WriteLine(txtRecord);
}
}
Console.ForegroundColor = ConsoleColor.White;
}
var nextUpdate = DateTime.Now.AddSeconds(150);
var waitMessage = "Wait for next call: ";
Console.Write(waitMessage);
while (nextUpdate > DateTime.Now)
{
Console.CursorLeft = waitMessage.Length;
Console.Write(" ");
Console.CursorLeft = waitMessage.Length;
var at = nextUpdate - DateTime.Now;
Console.Write($"{at.Hours}H {at.Minutes}M {at.Seconds}S");
Thread.Sleep(1000);
}
Console.Clear();
}
}
public TestResponse(TestClient testClient, IDnsQueryResponse response)
{
TestClient = testClient;
Response = response;
}
public SpfResponse(IDnsQueryResponse dnsReponse, IDnsQueryResponse spfDnsResponse)
{
this._TxtReponse = dnsReponse;
this._SpfReponse = spfDnsResponse;
}
static void Main(string[] args)
{
// 1.sending to one
MailAddress to = new MailAddress("*****@*****.**");
MailAddress from = new MailAddress("*****@*****.**");
MailMessage message = new MailMessage(from, to);
message.Subject = "Good morning";
message.Body = "Elizabeth, Harry, There are a few unpaid invoices for the Royal Wedding. Let's talk this over on Monday.;";
message.CC.Add(new MailAddress("*****@*****.**"));
message.Bcc.Add(new MailAddress("*****@*****.**"));
//2. sending with images
String imagePath = "bestpictureever.png";
LinkedResource LinkedImage = new LinkedResource(@imagePath);
LinkedImage.ContentId = "Wedding";
AlternateView htmlView = AlternateView.CreateAlternateViewFromString(
$"{message} <br> <img src=cid:Wedding>", null, "text/html"
);
htmlView.LinkedResources.Add(LinkedImage);
message.AlternateViews.Add(htmlView);
//3.sending to mulltiple clients
SmtpClient client = new SmtpClient("smtp.server.address", 2525)
{
Credentials = new NetworkCredential("smtp_username", "smtp_password"),
EnableSsl = true
};
// code in brackets above needed if authentication required
try
{
client.Send(message);
}
catch (SmtpException ex)
{
Console.WriteLine(ex.ToString());
}
//4. Sending without your own smtp/ using DNS client
LookupClient lookup = new LookupClient();
IDnsQueryResponse response = lookup.Query("westminster.co.uk", QueryType.MX);
foreach (DnsClient.Protocol.MxRecord record in response.Answers)
{
Console.WriteLine(ObjectDumper.Dump(record.Exchange));
SmtpClient client = new SmtpClient(record.Exchange, 25);
try
{
client.Send(message);
// if we reached this point, our email was sent and we can break the loop
break;
}
catch (SmtpException ex)
{
Console.WriteLine(ex.ToString());
}
}
}
public DmarcResponse(IDnsQueryResponse dnsReponse)
{
this._Reponse = dnsReponse;
}
public static string GetTTL(string host)
{
IDnsQueryResponse dnsQueryResponse = client.Query(host, QueryType.ANY);
return("");
}
static string ParseRecord(IDnsQueryResponse dnsQueryResponse, bool isA = false, bool isMx = false)
{
string output = "";
string value = "";
string ttl = "";
string mxp = "";
foreach (DnsResourceRecord record in dnsQueryResponse.Answers)
{
switch (record.RecordType)
{
case ResourceRecordType.MX:
{
MxRecord mxRecord = record as MxRecord;
if (mxRecord != null)
{
value += mxRecord.Exchange + "\n";
ttl += mxRecord.InitialTimeToLive + "\n";
mxp += mxRecord.Preference + "\n";
// output += $"{mxRecord.Exchange} | TTL {mxRecord.InitialTimeToLive}\n";
}
break;
}
case ResourceRecordType.SOA:
{
SoaRecord soaRecord = record as SoaRecord;
if (soaRecord != null)
{
value += soaRecord.ToString() + "\n";
ttl += soaRecord.Minimum + "\n";
// output += $"SOA TTL {soaRecord.Minimum}\n";
}
break;
}
case ResourceRecordType.NS:
{
NsRecord nsRecord = record as NsRecord;
if (nsRecord != null)
{
value += nsRecord.NSDName + "\n";
ttl += nsRecord.InitialTimeToLive + "\n";
// output += $"{nsRecord.NSDName} | TTL {nsRecord.InitialTimeToLive}\n";
}
break;
}
case ResourceRecordType.A:
{
ARecord nsRecord = record as ARecord;
if (nsRecord != null)
{
return($"{nsRecord.InitialTimeToLive}");
}
return("No record");
}
case ResourceRecordType.TXT:
{
TxtRecord txtRecord = record as TxtRecord;
if (txtRecord != null)
{
foreach (string txt in txtRecord.Text)
{
value += "\"\"" + txt + "\"\"\n";
ttl += txtRecord.InitialTimeToLive + "\n";
// output += $"\"{txt}\" | TTL {txtRecord.InitialTimeToLive}\n";
}
}
break;
}
}
}
if (!string.IsNullOrEmpty(value) && !string.IsNullOrEmpty(ttl))
{
if (string.IsNullOrEmpty(mxp))
{
output = $"\"{value.Trim()}\",\"{ttl.Trim()}\"";
}
else
{
output = $"\"{value.Trim()}\",\"{mxp.Trim()}\",\"{ttl.Trim()}\"";
}
}
else
{
if (isA)
{
output = "No record";
}
else if (isMx)
{
output = "No record,No record,No record";
}
else
{
output = "No record,No record";
}
}
if (string.IsNullOrEmpty(output))
{
return("No record\n");
}
return(output);
}
/// <inheritdoc />
public async Task SendMailAsync(string toDomain, IAsyncEnumerable <MailToSend> messages)
{
using SmtpClient client = new SmtpClient()
{
ServerCertificateValidationCallback = (object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors) =>
{
return(sslPolicyErrors == SslPolicyErrors.None ||
ignoreCertificateErrorsRegex.TryGetValue("*", out _) ||
(ignoreCertificateErrorsRegex.TryGetValue(toDomain, out Regex regex)) && regex.IsMatch(certificate.Subject));
}
};
IPHostEntry ip = null;
LookupClient lookup = new LookupClient();
MailDemonLog.Debug("QueryAsync mx for domain {0}", toDomain);
IDnsQueryResponse result = await lookup.QueryAsync(toDomain, QueryType.MX, cancellationToken : cancelToken);
bool connected = false;
foreach (DnsClient.Protocol.MxRecord record in result.AllRecords)
{
// attempt to send, if fail, try next address
try
{
MailDemonLog.Debug("GetHostEntryAsync for exchange {0}", record.Exchange);
ip = await Dns.GetHostEntryAsync(record.Exchange);
foreach (IPAddress ipAddress in ip.AddressList)
{
string host = ip.HostName;
try
{
if (!DisableSending)
{
await client.ConnectAsync(host, options : MailKit.Security.SecureSocketOptions.Auto, cancellationToken : cancelToken).TimeoutAfter(30000);
}
connected = true;
await foreach (MailToSend message in messages)
{
if (dkimSigner != null)
{
message.Message.Prepare(EncodingConstraint.SevenBit);
dkimSigner.Sign(message.Message, headersToSign);
}
try
{
if (!DisableSending)
{
MailDemonLog.Debug("Sending message to host {0}, from {1}, to {2}", host, message.Message.From, message.Message.To);
await client.SendAsync(message.Message, cancelToken).TimeoutAfter(30000);
MailDemonLog.Debug("Success message to host {0}, from {1}, to {2}", host, message.Message.From, message.Message.To);
}
// callback success
message.Callback?.Invoke(message.Subscription, string.Empty);
}
catch (Exception exInner)
{
MailDemonLog.Debug("Fail message to host {0}, from {1}, to {2} {3}", host, message.Message.From, message.Message.To, exInner);
// TODO: Handle SmtpCommandException: Greylisted, please try again in 180 seconds
// callback error
message.Callback?.Invoke(message.Subscription, exInner.Message);
}
}
}
catch (Exception ex)
{
// all messages fail for this domain
MailDemonLog.Error(host + " (" + toDomain + ")", ex);
await foreach (MailToSend message in messages)
{
message.Callback?.Invoke(message.Subscription, ex.Message);
}
}
finally
{
try
{
await client.DisconnectAsync(true, cancelToken);
}
catch
{
}
}
if (connected)
{
// we successfuly got a mail server, don't loop more ips
break;
}
}
}
catch (InvalidOperationException)
{
throw;
}
catch (Exception ex)
{
// dns error, move on to next mail server
MailDemonLog.Error(toDomain, ex);
}
if (connected)
{
// we successfuly got a mail server, don't loop more dns entries
break;
}
}
}
public MxResponse(IDnsQueryResponse dnssecRecords)
{
this._Reponse = dnssecRecords;
}
public EtcdClient(string connectionString, int port = 2379,
HttpClientHandler handler = null, bool ssl = false,
bool useLegacyRpcExceptionForCancellation = false)
{
if (string.IsNullOrWhiteSpace(connectionString))
{
throw new Exception("etcd connection string is empty.");
}
string[] hosts;
if (connectionString.ToLowerInvariant().StartsWith("discovery-srv://"))
{
// Expecting it to be discovery-srv://{domain}/{name}
// Examples:
// discovery-srv://my-domain.local/ would expect entries for either _etcd-client-ssl._tcp.my-domain.local or _etcd-client._tcp.my-domain.local
// discovery-srv://my-domain.local/project1 would expect entries for either _etcd-client-ssl-project1._tcp.my-domain.local or _etcd-client-project1._tcp.my-domain.local
Uri discoverySrv = new Uri(connectionString);
LookupClient client = new LookupClient(new LookupClientOptions
{
UseCache = true
});
// SSL first ...
string serviceName = "/".Equals(discoverySrv.AbsolutePath)
? ""
: $"-{discoverySrv.AbsolutePath.Substring(startIndex: 1, length: discoverySrv.AbsolutePath.Length - 1)}";
IDnsQueryResponse result = client.Query($"_etcd-client-ssl{serviceName}._tcp.{discoverySrv.Host}", QueryType.SRV);
string scheme = "https";
if (result.HasError)
{
scheme = "http";
// No SSL ...
result = client.Query($"_etcd-client{serviceName}._tcp.{discoverySrv.Host}", QueryType.SRV);
if (result.HasError)
{
throw new InvalidOperationException(result.ErrorMessage);
}
}
List <SrvRecord> results = result.Answers.OfType <SrvRecord>().OrderBy(a => a.Priority)
.ThenByDescending(a => a.Weight).ToList();
hosts = new string[results.Count];
for (int index = 0; index < results.Count; index++)
{
SrvRecord srvRecord = results[index];
DnsResourceRecord additionalRecord =
result.Additionals.FirstOrDefault(p => p.DomainName.Equals(srvRecord.Target));
string host = srvRecord.Target.Value;
if (additionalRecord is ARecord aRecord)
{
host = aRecord.Address.ToString();
}
else if (additionalRecord is CNameRecord cname)
{
host = cname.CanonicalName;
}
if (host.EndsWith("."))
{
host = host.Substring(startIndex: 0, host.Length - 1);
}
hosts[index] = $"{scheme}://{host}:{srvRecord.Port}";
}
}
else
{
hosts = connectionString.Split(',');
}
List <Uri> nodes = new List <Uri>();
for (int i = 0; i < hosts.Length; i++)
{
string host = hosts[i];
if (host.Split(':').Length < 3)
{
host += $":{Convert.ToString(port)}";
}
if (!(host.StartsWith(InsecurePrefix) || host.StartsWith(SecurePrefix)))
{
if (ssl)
{
host = $"{SecurePrefix}{host}";
}
else
{
host = $"{InsecurePrefix}{host}";
}
}
nodes.Add(new Uri(host));
}
_balancer = new Balancer(nodes, handler, ssl, useLegacyRpcExceptionForCancellation);
}