private static Task DnsServer_QueryReceived(object sender, QueryReceivedEventArgs eventArgs)
{
eventArgs.Query.IsQuery = false;
DnsMessage query = eventArgs.Query as DnsMessage;
if (query == null || query.Questions.Count <= 0)
{
query.ReturnCode = ReturnCode.ServerFailure;
}
else
{
if (query.Questions[0].RecordType == RecordType.A)
{
foreach (DnsQuestion dnsQuestion in query.Questions)
{
//string resolvedIp = Resolve(clientAddress.ToString(), dnsQuestion.Name);
ARecord aRecord = new ARecord(dnsQuestion.Name, 36000, ipAddress);
query.AnswerRecords.Add(aRecord);
}
}
else
{
return(null);
}
}
eventArgs.Response = eventArgs.Query;
return(Task.CompletedTask);
}
/// <summary>
/// Gets the IP address for the domain name
/// </summary>
/// <param name="domainName"></param>
/// <returns>IPAddress</returns>
public IPAddress GetIPAddress(string domainName)
{
try
{
//try the domain
ARecord aRecord = GetARecord(domainName);
//if null try the www subdomain
if (Object.Equals(aRecord, null))
{
aRecord = GetARecord("www." + domainName);
}
if (!Object.Equals(aRecord, null))
{
//compare address to known malicious list before returning
if (!_maliciousList.Contains(aRecord.IpAddress.ToString()))
{
return(aRecord.IpAddress);
}
else
{
Utility.WriteToLogFile(String.Format("SmallBiz_MaliciousIPs_{0:M_d_yyyy}", DateTime.Today) + ".log"
, String.Format("{0} is a known malicious ip associated with {1}", aRecord.IpAddress.ToString(), domainName));
}
}
}
catch (Exception e)
{
ExceptionExtensions.LogError(e, "Dig.GetIPAddress", "Domain: " + domainName);
}
return(null);
}
/// <summary>
/// Acts as a Factory which reads QType from Immutable IResource param to return concrete type which implements IResource.
/// </summary>
/// <param name="data"></param>
/// <param name="position"></param>
/// <param name="resource"></param>
/// <returns></returns>
private static IResource ReadAnswer(ref byte[] data, int position, IResource resource)
{
switch (resource.Type)
{
case QType.TXT:
return(TxtRecord.Parse(data, position, resource));
case QType.MX:
return(MxRecord.Parse(data, position, resource));
case QType.A:
return(ARecord.Parse(data, position, resource));
case QType.SOA:
return(SoaRecord.Parse(data, position, resource));
case QType.NS:
return(NsRecord.Parse(data, position, resource));
case QType.CNAME:
return(CNameRecord.Parse(data, position, resource));
}
return(null); //TODO: Thrown Exception Here
}
public FrontendStack(Construct scope, string name, string url, StackProps props = null) : base(scope, $"frontend-{name}", props)
{
// pricing - hosted zone
// 0,50 USD por zona hospedada/mês para as primeiras 25 zonas hospedadas
// 0,10 USD por zona hospedada/mês para zonas hospedadas adicionais
// Consultas padrão
// 0,40 USD por milhão de consultas – primeiro 1 bilhão de consultas/mês
// 0,20 USD por milhão de consultas – mais de 1 bilhão de consultas/mês
// Consultas de roteamento baseado em latência
// 0,60 USD por milhão de consultas – primeiro 1 bilhão de consultas/mês
// 0,30 USD por milhão de consultas – mais de 1 bilhão de consultas/mês
// Consultas de Geo DNS e geoproximidade
// 0,70 USD por milhão de consultas -- primeiro 1 bilhão de consultas/mês
// 0,35 USD por milhão de consultas -- mais de 1 bilhão de consultas/mês
_bucket = new Bucket(this, $"frontend-{name}-bucket", new BucketProps()
{
BucketName = name + "72b302bf297a228a75730123efef7c41",
WebsiteIndexDocument = "index.html",
PublicReadAccess = true,
RemovalPolicy = RemovalPolicy.DESTROY
});
_bucketDeployment = new BucketDeployment(this, $"frontend-{name}-deployment", new BucketDeploymentProps()
{
Sources = new[] { Source.Asset("../tools/frontend/") },
DestinationBucket = _bucket,
RetainOnDelete = false
});
_hostedZone = new HostedZone(this, $"frontend-{name}-hostedzone", new HostedZoneProps
{
ZoneName = url
});
_certificate = new Certificate(this, $"frontend-{name}-certificate", new CertificateProps
{
DomainName = url,
Validation = CertificateValidation.FromDns(_hostedZone)
});
_distribution = new Distribution(this, $"frontend-{name}-distribution", new DistributionProps
{
DefaultBehavior = new BehaviorOptions
{
Origin = new S3Origin(_bucket),
ViewerProtocolPolicy = ViewerProtocolPolicy.REDIRECT_TO_HTTPS
},
DomainNames = new[] { url },
Certificate = _certificate,
DefaultRootObject = "index.html"
});
_aRecord = new ARecord(this, $"frontend-{name}-arecord", new ARecordProps
{
Zone = _hostedZone,
RecordName = url,
Target = RecordTarget.FromAlias(new CloudFrontTarget(_distribution))
});
}
/// <summary>
/// 消息队列处理
/// </summary>
/// <param name="sender"></param>
/// <param name="eventArgs"></param>
/// <returns></returns>
private Task DnsServer_QueryReceived(object sender, QueryReceivedEventArgs eventArgs)
{
return(Task.Run(() =>
{
var message = eventArgs.Query;
var clientAddress = eventArgs.RemoteEndpoint;
message.IsQuery = false;
DnsMessage query = message as DnsMessage;
if (query == null || query.Questions.Count <= 0)
{
message.ReturnCode = ReturnCode.ServerFailure;
}
else
{
if (query.Questions[0].RecordType == RecordType.A)
{
foreach (DnsQuestion dnsQuestion in query.Questions)
{
string resolvedIp = Resolve(clientAddress.ToString(), dnsQuestion.Name.ToString());
ARecord aRecord = new ARecord(query.Questions[0].Name, 36000, IPAddress.Parse(resolvedIp));
query.AnswerRecords.Add(aRecord);
}
}
}
eventArgs.Response = message;
}));
}
public void DnsRecordFactory_ResolveARecord()
{
var header = new DnsResponseHeader(42, 256, 0, 1, 0, 0);
var responseMessage = new DnsResponseMessage(header, 0);
var info = new ResourceRecordInfo("query", ResourceRecordType.A, QueryClass.IN, 100, 4);
var ip = IPAddress.Parse("123.45.67.9");
var answer = new ARecord(info, ip);
responseMessage.AddAnswer(answer);
var response = responseMessage.AsQueryResponse(new NameServer(ip));
var answerBytes = ip.GetAddressBytes();
var raw = GetResponseBytes(response, answerBytes);
var handle = new DnsUdpMessageHandler(true);
var result = handle.GetResponseMessage(new System.ArraySegment <byte>(raw)).AsQueryResponse(new NameServer(ip));
Assert.Equal(result.Answers.Count, 1);
var resultAnswer = result.Answers.OfType <ARecord>().First();
Assert.Equal(resultAnswer.Address.ToString(), ip.ToString());
Assert.Equal(resultAnswer.DomainName.Value, "query.");
Assert.Equal(resultAnswer.RawDataLength, 4);
Assert.Equal(resultAnswer.RecordClass, QueryClass.IN);
Assert.Equal(resultAnswer.RecordType, ResourceRecordType.A);
Assert.True(resultAnswer.TimeToLive == 100);
Assert.True(result.Header.Id == 42);
Assert.True(result.Header.AnswerCount == 1);
}
//委托实现方法，可自定义解析规则
static DnsMessageBase ProcessQuery(DnsMessageBase message, IPAddress clientAddress, ProtocolType protocol)
{
message.IsQuery = false;
DnsMessage query = message as DnsMessage;
if (query == null || query.Questions.Count <= 0)
{
message.ReturnCode = ReturnCode.ServerFailure;
}
else
{
if (query.Questions[0].RecordType == RecordType.A)
{
//自定义解析规则，clientAddress即客户端的IP，dnsQuestion.Name即客户端请求的域名，Resolve为自定义的方法（代码不再贴出），返回解析后的ip，将其加入AnswerRecords中
foreach (DnsQuestion dnsQuestion in query.Questions)
{
//string resolvedIp = Resolve(clientAddress.ToString(), dnsQuestion.Name);
ARecord aRecord = new ARecord(dnsQuestion.Name, 36000, ipAddress);
query.AnswerRecords.Add(aRecord);
}
}
else
{
return(null);
}
//如果为IPV6请求，则交给上级DNS服务器处理，代码不再贴出
}
return(message);
}
public void ResolveMapOnlyArrayTest()
{
var q = new DnsQuestion("maponlyarray.bit", RecordType.Any, RecordClass.Any);
string expectedA1 = "1.2.3.4";
string expectedA2 = "4.3.2.1";
string expectedAAAA = "2400:cb00:2049:1::adf5:3b6b";
var answer = resolver.GetAnswer(q);
var Aanswers = answer.AnswerRecords.Where(m => m.RecordType == RecordType.A);
var AAAAanswers = answer.AnswerRecords.Where(m => m.RecordType == RecordType.Aaaa);
Assert.IsInstanceOfType(Aanswers.First(), typeof(ARecord));
ARecord a1 = Aanswers.First() as ARecord;
ARecord a2 = Aanswers.Last() as ARecord;
AaaaRecord aaaa = AAAAanswers.First() as AaaaRecord;
Assert.AreEqual(expectedA1, a1.Address.ToString());
Assert.AreEqual(expectedA2, a2.Address.ToString());
Assert.AreEqual(expectedAAAA, aaaa.Address.ToString());
}
public void TestARecord()
{
var record = new ARecord("F00.tESt", "001.02.3.40");
Assert.AreEqual("1.2.3.40", record.IPv4);
Assert.AreEqual("F00.tESt", record.Name);
}
public async Task MockLookup()
{
// arrange
var lookupMock = new Mock <IDnsQuery>();
var aRecord = new ARecord(new ResourceRecordInfo("query", ResourceRecordType.A, QueryClass.IN, 0, 0), IPAddress.Any);
var responseMsg = new DnsResponseMessage(new DnsResponseHeader(123, 256, 1, 1, 0, 1), 123);
responseMsg.Answers.Add(aRecord);
IDnsQueryResponse dnsResponse = responseMsg.AsQueryResponse(new NameServer(NameServer.GooglePublicDns));
//// or mock response
//var dnsResponseMock = new Mock<IDnsQueryResponse>();
//dnsResponseMock
// .Setup(p => p.Answers)
// .Returns(new DnsResourceRecord[] { aRecord });
Task <IDnsQueryResponse> response = Task.FromResult(dnsResponse);
lookupMock.Setup(f => f.QueryAsync(It.IsAny <string>(), QueryType.A)).Returns(response);
var lookup = lookupMock.Object;
// act
var result = await lookup.QueryAsync("query", QueryType.A);
// assert
Assert.Equal(1, result.Header.AnswerCount);
Assert.Equal("query.", result.Answers.First().DomainName.Value);
Assert.Equal(IPAddress.Any, result.Answers.ARecords().First().Address);
}
public void Dig()
{
try
{
//初始化DnsClient，第一个参数为DNS服务器的IP，第二个参数为超时时间
DnsClient dnsClient = new DnsClient(IPAddress.Parse(DnsServer), TimeOut);
//解析域名。将域名请求发送至DNS服务器解析，参数为需要解析的域名
DnsMessage dnsMessage = dnsClient.Resolve(DomainName.Parse(Domain));
//TimeSpan = s.Elapsed;
//若返回结果为空，或者存在错误，则该请求失败。
if (dnsMessage == null || (dnsMessage.ReturnCode != ReturnCode.NoError && dnsMessage.ReturnCode != ReturnCode.NxDomain))
{
IsSuccess = false;
return;
}
//循环遍历返回结果，将返回的IPV4记录添加到结果集List中。
if (dnsMessage != null)
{
foreach (DnsRecordBase dnsRecord in dnsMessage.AnswerRecords)
{
ARecord AR = dnsRecord as ARecord;
if (AR != null)
{
IsSuccess = true;
Record.Add(AR.Address.ToString());
}
}
}
}
catch (Exception)
{
}
}
private Uri ConstructUrl(IRequest originalRequest, IPEndPoint remote)
{
if (!state_.IsLocal(remote.Address))
{
return(originalRequest.Uri);
}
DnsMessage message = state_.Dns.Resolve(originalRequest.Uri.DnsSafeHost);
if (null == message)
{
throw new ApplicationException(string.Format("Could not resolve '{0}' with DNS '{1}'", originalRequest.Uri.DnsSafeHost, state_.Config.Dns.Server));
}
foreach (DnsRecordBase recordBase in message.AnswerRecords)
{
ARecord record = recordBase as ARecord;
if (record == null)
{
continue;
}
string host = originalRequest.Uri.Host;
string url = originalRequest.Uri.AbsoluteUri.Replace(host, record.Address.ToString());
return(new Uri(url));
}
return(originalRequest.Uri);
}
public DnsResourceRecord GetRecord(BaseResourceRecordInfo info, ArraySegment <byte> data)
{
if (info == null)
{
throw new ArgumentNullException(nameof(info));
}
int oldIndex = _reader.Index;
DnsResourceRecord result;
switch (info.RecordType)
{
case ResourceRecordType.A:
IPAddress ipaddress = _reader.ReadIPAddress(data);
result = new ARecord(info, ipaddress);
break;
default:
// update reader index because we don't read full data for the empty record
_reader.Advance(info.RawDataLength);
result = new EmptyRecord(info);
break;
}
// sanity check
if (_reader.Index != oldIndex + info.RawDataLength)
{
throw new InvalidOperationException("Record reader index out of sync.");
}
return(result);
}
private void SetupReponse([NotNull] DnsMessage query, [NotNull] DnsQuestion question)
{
var record = new ARecord(question.Name, 100, _serverIP);
query.AnswerRecords.Add(record);
query.ReturnCode = ReturnCode.NoError;
}
private void ProcessARecord(ARecord record)
{
string hostname = record.Name;
string ip = record.Address;
if (!_discoveredIPs.ContainsKey(hostname))
{
_discoveredIPs.Add(hostname, new List <string>());
}
if (!_discoveredIPs[hostname].Contains(ip))
{
_discoveredIPs[hostname].Insert(0, ip);
}
// Update existing services
var services = _discoveredServices.Values.Where(s => s.Hostname == hostname);
foreach (var service in services)
{
if (!service.IPAddresses.Contains(ip))
{
service.IPAddresses.Insert(0, ip);
}
}
}
public async Task <bool> ZoneIsUpToDate(string Hostname, RecordType recordType, string zoneAddress)
{
RecordSet recordSet = await RecordSet(Hostname, recordType);
if (recordType == RecordType.A)
{
ARecord aRecord = new ARecord(zoneAddress);
foreach (ARecord rec in recordSet.ARecords)
{
string CurrentAddress = rec.Ipv4Address;
if (CurrentAddress.Equals(zoneAddress))
{
return(true);
}
}
return(false);
}
if (recordType == RecordType.AAAA)
{
AaaaRecord aaaaRecord = new AaaaRecord(zoneAddress);
foreach (AaaaRecord rec in recordSet.AaaaRecords)
{
string CurrentAddress = rec.Ipv6Address;
if (CurrentAddress.Equals(zoneAddress))
{
return(true);
}
}
return(false);
}
return(false);
}
public void Resolve_should_successfully_resolve_in_ARecord_domainName_using_IPEndpoint_and_DnsMessageRequest_overload()
{
// Arrange.
const string domainNameToResolve = "www.A-Dummy-Domain.com";
const string domainNameToResolveRoot = domainNameToResolve + ".";
const ushort headerId = 12345;
const string ipAddress = "10.50.75.40";
DnsRequestMessage requestMessage = GetDnsRequestMessage(headerId);
IPEndPoint dnsServerIP = new IPEndPoint(IPAddress.Parse(ipAddress), dnsPort53);
DnsResponseMessage responseMessage = GetDnsResponseMessage(headerId, ipAddress, domainNameToResolveRoot);
mockMessageProcessor.Setup(m => m.ProcessResponse(It.IsAny <ArraySegment <byte> >())).Returns(responseMessage);
mockDnsString.Setup(m => m.Value).Returns(domainNameToResolveRoot);
mockUdpSocket.Setup(m => m.Receive(It.IsAny <byte[]>(), It.Is <int>(i => i == 0), It.Is <int>(i => i == ReadSize), It.Is <SocketFlags>(s => s == SocketFlags.None)))
.Returns(1000);
IDnsResolver resolver = new DnsResolver(mockCommunicator.Object, mockMessageProcessor.Object);
// Act.
DnsResponseMessage response = resolver.Resolve(dnsServerIP, requestMessage);
// Assert.
Assert.IsInstanceOf(typeof(ARecord), response.Answers[0]);
ARecord arecord = response.Answers[0] as ARecord;
Assert.AreEqual(domainNameToResolveRoot, response.Answers[0].DomainName.Value);
Assert.AreEqual(ipAddress, arecord.Address.ToString());
}
public void ProcessResponse_should_return_DnsResponseMessage_object_with_1_answer_1_question_only_successfully()
{
// Arrange.
const string domainNameToResolve = "www.microsoft.com";
const string domainNameToResolveRoot = domainNameToResolve + ".";
const string ipAddress = "10.1.1.100";
const ushort headerId = 1001;
IDnsString dnsString = new DnsString(domainNameToResolve, domainNameToResolveRoot);
ArraySegment <byte> responseData = GetSampleData(ResponseDataSampleFile.QuestionAndAnswerQuery);
mockReader.SetupSequence(m => m.ReadUInt16NetworkOrder(responseData))
.Returns(headerId) // id
.Returns(33152) // flags
.Returns(1) // questionCount
.Returns(1) // answerCount
.Returns(0) // nameServerCount - setting it to zero for this unit test
.Returns(0) // additionCount
.Returns(1) // QueryType
.Returns(1) // QueryClass
// BaseResourceRecordInfo
.Returns(1) // record type
.Returns(1) //query class
.Returns(4); //// RDLength
mockReader.Setup(m => m.ReadUInt32NetworkOrder(responseData)).Returns(12); // ttl - 32bit!!
// question
mockReader.SetupSequence(m => m.ReadQuestionQueryString(responseData))
.Returns(dnsString) // question
.Returns(dnsString); // ReadRecordInfo
mockReader.Setup(m => m.ReadIPAddress(responseData)).Returns(IPAddress.Parse(ipAddress));
mockReader.SetupSequence(m => m.Index).Returns(8).Returns(12);
INetworkMessageProcessor messageProcessor = new DnsQueryMessageProcessor(mockReader.Object, mockDnsString.Object);
// Act.
DnsResponseMessage response = messageProcessor.ProcessResponse(responseData);
// Assert.
Assert.AreEqual(1, response.Answers.Count);
Assert.AreEqual(1, response.Questions.Count);
Assert.AreEqual(0, response.Additionals.Count);
Assert.AreEqual(0, response.Authorities.Count);
Assert.AreEqual(headerId, response.Header.Identifier);
Assert.IsInstanceOf <ARecord>(response.Answers[0]);
ARecord arecord = response.Answers[0] as ARecord;
Assert.AreEqual(domainNameToResolveRoot, response.Answers[0].DomainName.Value);
Assert.AreEqual(ipAddress, arecord.Address.ToString());
// question check
Assert.AreEqual(QueryClass.IN, response.Questions[0].QuestionClass);
Assert.AreEqual(QueryType.A, response.Questions[0].QuestionType);
Assert.AreEqual(domainNameToResolveRoot, response.Questions[0].QueryName.Value);
}
private void SetupReponse(DnsMessage query, DnsQuestion question)
{
var ip = IPAddress.Parse(_serverIp);
ARecord record = new ARecord(question.Name, 100, ip);
query.AnswerRecords.Add(record);
query.ReturnCode = ReturnCode.NoError;
}
private static void PrintResult(DnsResponseMessage response)
{
Console.WriteLine("\nDomain Name\t\tRecord Type\tRecord Class\tTime to live\tIP Address");
Console.WriteLine("--------------------------------------------------------------------------------------------|");
foreach (DnsResourceRecord nextRec in response.Answers)
{
ARecord rec = nextRec as ARecord;
Console.WriteLine($"{nextRec.DomainName.Value.TrimEnd('.')}\t\t{nextRec.RecordType}\t\t{nextRec.RecordClass}\t\t{nextRec.TimeToLive}\t\t{rec?.Address}");
}
}
private static IRecord ReadRecord(ByteReader byteReader)
{
var name = DnsUtils.ReadName(byteReader);
var rtype = byteReader.GetUshort();
var rclass = byteReader.GetUshort();
var ttl = byteReader.GetUint();
if ((RecordType)rtype == RecordType.NS)
{
var record = new NSRecord()
{
Name = name,
RClass = rclass,
Ttl = ttl,
};
var rdlength = byteReader.GetUshort();
record.Host = ReadName(byteReader);
return(record);
}
else if ((RecordType)rtype == RecordType.A)
{
var rdlength = byteReader.GetUshort();
var ipv4 = ReadIpv4(byteReader);
var record = new ARecord(name, ipv4)
{
RClass = rclass,
Ttl = ttl,
};
return(record);
}
else if ((RecordType)rtype == RecordType.AAAA)
{
var rdlength = byteReader.GetUshort();
var ipv6 = ReadIpv6(byteReader);
var record = new AaaaRecord(name, ipv6)
{
RClass = rclass,
Ttl = ttl,
};
return(record);
}
else
{
var record = new Record()
{
Name = name,
RType = rtype,
RClass = (ushort)rclass,
Ttl = ttl,
};
var rdlength = byteReader.GetUshort();
record.RData = byteReader.GetBytes(rdlength);
return(record);
}
}
public void OnChange(ARecord entity, UpdateOperations operation)
{
switch (operation)
{
case UpdateOperations.Add:
case UpdateOperations.Change:
entity.ChangedDate = DateTime.Now;
entity.Key = Guid.NewGuid(); // setting next value for concurrency column, check is based on original value
break;
}
}
static void Main(string[] args)
{
var ctx = new ConcurrencyTestDataContext();
var entityA = new ARecord {
Value = "[0] created payload"
};
ctx.ARecords.Add(entityA);
ctx.SaveChanges();
entityA.Value = string.Format("[1] updated payload at {0}", DateTime.Now);
ctx.SaveChanges();
entityA.Value = string.Format("[2] updated payload at {0}", DateTime.Now);
ctx.SaveChanges();
var entityB = new BRecord {
Value = "[0] created payload"
};
ctx.BRecords.Add(entityB);
ctx.SaveChanges();
entityB.Value = string.Format("[1] updated payload at {0}", DateTime.Now);
ctx.SaveChanges();
entityB.Value = string.Format("[2] updated payload at {0}", DateTime.Now);
ctx.SaveChanges();
var entityC = new CRecord {
Value = "[0] created payload"
};
ctx.CRecords.Add(entityC);
ctx.SaveChanges();
entityC.Value = string.Format("[1] updated payload at {0}", DateTime.Now);
ctx.SaveChanges();
entityC.Value = string.Format("[2] updated payload at {0}", DateTime.Now);
ctx.SaveChanges();
var newContext = new ConcurrencyTestDataContext();
entityC.Value = string.Format("[3] updated payload at {0} via new data context", DateTime.Now);
newContext.Attach(entityC);
newContext.SaveChanges();
}
public void ResolveMapNestTest()
{
var q = new DnsQuestion("www.nest.bit", RecordType.Any, RecordClass.Any);
string expectedA = "178.248.244.15";
var answer = resolver.GetAnswer(q);
Assert.IsInstanceOfType(answer.AnswerRecords.First(), typeof(ARecord));
ARecord a = answer.AnswerRecords.First() as ARecord;
Assert.AreEqual(expectedA, a.Address.ToString());
}
private static void RunServer()
{
var service = "_appletv.local.appletv._local.appletv.local.appletv.local";
var mdns = new MulticastService();
mdns.QueryReceived += (s, e) =>
{
var msg = e.Message;
if (msg.Questions.Any(q => q.Name == service))
{
var res = msg.CreateResponse();
var addresses = MulticastService.GetIPAddresses()
.Where(ip => ip.AddressFamily == AddressFamily.InterNetwork);
foreach (var address in addresses)
{
var ar = new ARecord
{
Name = service,
Address = address
};
var writer = new PresentationWriter(new StringWriter());
writer.WriteString("123qweq");
ar.WriteData(writer);
ar.Name = "qweqeqweq";
res.Answers.Add(ar);
}
mdns.SendAnswer(res);
}
};
advertiseThread = new Thread(new ThreadStart(() =>
{
sd = new ServiceDiscovery(mdns);
var sp = new ServiceProfile("_itxpt_multicast._tcp.", "_itxpt._tcp", 5353, new List <IPAddress> {
IPAddress.Parse("192.168.88.239")
});
//sp.AddProperty("host", "192.168.88.239");
//sp.AddProperty("port", "14005");
sp.Resources.Add(new ARecord {
Name = "_itxpt_multicast._tcp.", Address = IPAddress.Parse("192.168.88.239"), Class = DnsClass.ANY
});
sp.Resources.Add(new SRVRecord {
Name = "_itxpt_multicast._tcp.", Port = 5353, Priority = 0, Weight = 0, Class = DnsClass.ANY
});
sp.Resources.Add(new PTRRecord {
Name = "_itxpt_multicast._tcp.", DomainName = "192.168.88.239"
});
sd.Advertise(sp);
}));
advertiseThread.Start();
mdns.Start();
}
private ARecord DiscoveryDnsRecord(Output <string> resourceGroupName, Zone privateDns, Output <string>[] ipAddresses)
{
var discoveryRecord = new ARecord($"a-{DiscoveryRecordName}", new ARecordArgs
{
ResourceGroupName = resourceGroupName,
ZoneName = privateDns.Name,
Name = DiscoveryRecordName,
Records = ipAddresses,
Ttl = 300
});
return(discoveryRecord);
}
private async Task DnsServer_QueryReceived(object sender, QueryReceivedEventArgs eventArgs)
{
DnsMessage message = eventArgs.Query as DnsMessage;
if (message == null)
{
return;
}
DnsMessage response = message.CreateResponseInstance();
if ((message.Questions.Count == 1))
{
DnsQuestion question = message.Questions[0];
var fullAddress = string.Join(".", question.Name.Labels);
if (this.blockedList.Contains(fullAddress))
{
ARecord fakeRecord = new ARecord(question.Name, 10, this.loopbackIpAddress);
response.ReturnCode = ReturnCode.NoError;
Debug.WriteLine("Blocked: " + fullAddress);
eventArgs.Response = response;
return;
}
// send query to upstream server
DnsMessage upstreamResponse = await this.dnsClient.ResolveAsync(question.Name, question.RecordType, question.RecordClass);
var answer = upstreamResponse.AnswerRecords.FirstOrDefault();
// if got an answer, copy it to the message sent to the client
if (answer != null)
{
foreach (DnsRecordBase record in (upstreamResponse.AnswerRecords))
{
response.AnswerRecords.Add(record);
}
foreach (DnsRecordBase record in (upstreamResponse.AdditionalRecords))
{
response.AdditionalRecords.Add(record);
}
response.ReturnCode = ReturnCode.NoError;
// set the response
eventArgs.Response = response;
}
}
}
private void DnsRecord(Output <string> resourceGroupName, Zone privateDns, Output <string> ipAddress, int vnetRangePrefix, Resource[] dependencies)
{
var nodeRecord = new ARecord($"a-{DeploymentName}{vnetRangePrefix / 2 + 1}", new ARecordArgs
{
ResourceGroupName = resourceGroupName,
ZoneName = privateDns.Name,
Name = $"{DeploymentName}{vnetRangePrefix / 2 + 1}",
Records = { ipAddress },
Ttl = 300
},
new CustomResourceOptions
{
DependsOn = dependencies
});
}
/// <summary>
/// Do DNS queries to get any A records associated with the custom hostname the user has entered.
/// Puts the string output of the A record listing into the AppService argument so the list can be used later.
/// </summary>
/// <param name="appService">The object that holds all of the information the user has given, including the custom hostname.</param>
public static void GetHostnameARecords(AppService appService, DNSCheckErrors dnsCheckErrors)
{
//IDnsResolver resolver = new DnsStubResolver();
// This is moved into the AppService class itself to prevent making the string multiple times
// string fullHostnameDNSStyle = appService.CustomHostname + ".";
try
{
//List<ARecord> aRecords = DnsResolverExtensions.Resolve<ARecord>(resolver, appService.CustomHostname, RecordType.A, RecordClass.Any);
List <string> aRecordsStrings = new List <string>();
DnsMessage dnsMessage = DnsClient.Default.Resolve(DomainName.Parse(appService.CustomHostname), RecordType.A);
if ((dnsMessage == null) || ((dnsMessage.ReturnCode != ReturnCode.NoError) && (dnsMessage.ReturnCode != ReturnCode.NxDomain)))
{
throw new Exception("DNS request failed");
}
else
{
foreach (DnsRecordBase dnsRecord in dnsMessage.AnswerRecords)
{
if (dnsRecord.RecordType == RecordType.A && dnsRecord.Name.ToString() == appService.CustomHostnameDNSStyle)
{
ARecord aRecord = dnsRecord as ARecord;
if (aRecord != null)
{
aRecordsStrings.Add(aRecord.Address.ToString());
}
}
}
}
/*
* List<string> aRecordsStrings = new List<string>();
* foreach (ARecord aRecord in aRecords)
* {
* aRecordsStrings.Add(aRecord.Address.ToString());
* } */
appService.HostnameARecords = aRecordsStrings;
}
catch
{
dnsCheckErrors.hostnameARecordLookupFailed = true;
dnsCheckErrors.currentDNSFailures++;
}
}
private static DnsMessage ReplaceARecords(DnsMessage response, DnsMessage dnsMessage)
{
var newRecords = new List <DnsRecordBase>();
foreach (var answerRecord in response.AnswerRecords)
{
switch (answerRecord)
{
case ARecord _:
var newARecord = new ARecord(answerRecord.Name, answerRecord.TimeToLive, IPAddress.Loopback);
newRecords.Add(newARecord);
break;
case AaaaRecord _:
var newAaaaRecord = new AaaaRecord(answerRecord.Name, answerRecord.TimeToLive, IPAddress.IPv6Loopback);
newRecords.Add(newAaaaRecord);
break;
default:
newRecords.Add(answerRecord);
break;
}
}
return(new DnsMessage
{
Questions = dnsMessage.Questions,
IsQuery = false,
AdditionalRecords = response.AdditionalRecords,
AnswerRecords = newRecords,
AuthorityRecords = response.AuthorityRecords,
EDnsOptions = response.EDnsOptions,
IsAuthenticData = response.IsAuthenticData,
IsAuthoritiveAnswer = response.IsAuthoritiveAnswer,
IsCheckingDisabled = response.IsCheckingDisabled,
IsDnsSecOk = response.IsDnsSecOk,
IsEDnsEnabled = response.IsAuthenticData,
IsRecursionAllowed = response.IsRecursionAllowed,
IsRecursionDesired = response.IsRecursionDesired,
IsTruncated = response.IsTruncated,
OperationCode = response.OperationCode,
ReturnCode = response.ReturnCode,
TSigOptions = response.TSigOptions,
TransactionID = response.TransactionID
});
}
public override void ExecuteCmdlet()
{
DnsRecordBase result = null;
switch (this.ParameterSetName)
{
case ParameterSetA:
{
result = new ARecord { Ipv4Address = this.Ipv4Address };
break;
}
case ParameterSetAaaa:
{
result = new AaaaRecord { Ipv6Address = this.Ipv6Address };
break;
}
case ParameterSetMx:
{
result = new MxRecord { Preference = this.Preference, Exchange = this.Exchange };
break;
}
case ParameterSetNs:
{
result = new NsRecord { Nsdname = this.Nsdname };
break;
}
case ParameterSetSrv:
{
result = new SrvRecord { Priority = this.Priority, Port = this.Port, Target = this.Target, Weight = this.Weight };
break;
}
case ParameterSetTxt:
{
result = new TxtRecord { Value = this.Value };
break;
}
case ParameterSetCName:
{
result = new CnameRecord { Cname = this.Cname };
break;
}
case ParameterSetPtr:
{
result = new PtrRecord {Ptrdname = this.Ptrdname};
break;
}
default:
{
throw new PSArgumentException(string.Format(ProjectResources.Error_UnknownParameterSetName, this.ParameterSetName));
}
}
WriteObject(result);
}
