Skip to content

Commit 60c7a85

Browse files
rzikmCopilot
andcommitted
Fail over on SERVFAIL/REFUSED, reject malformed answers, cache resolv.conf
- SendQuery now treats a SERVFAIL/REFUSED response code as a soft error: the query fails over to the next configured server, retaining the response so it is surfaced only when no server produces a definitive answer. Buffers are released on every exit path. - ParseAddresses now throws InvalidDataException when an answer record matches the queried type but cannot be parsed (e.g. an A record whose RDLENGTH is not 4), instead of silently reporting NODATA. - ResolvConf caches the parsed /etc/resolv.conf and re-parses only when the file's last-write time changes, avoiding a file read per query. - Add loopback tests for server failover, all-servers-fail, and malformed answer records (managed resolver only). Co-authored-by: Copilot <[email protected]> Copilot-Session: db7d5bba-0fcb-4a39-bbe2-fc24b2092abf
1 parent 24283c1 commit 60c7a85

3 files changed

Lines changed: 183 additions & 2 deletions

File tree

‎src/libraries/System.Net.NameResolution/src/System/Net/DnsResolverPal.Managed.cs‎

Lines changed: 80 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -126,12 +126,29 @@ private static DnsResult<AddressRecord> ParseAddresses(ReadOnlySpan<byte> respon
126126
for (int i = 0; i < header.AnswerCount; i++)
127127
{
128128
DnsRecord record = ReadRecord(ref reader);
129-
if (qtype == DnsRecordType.A && record.TryParseARecord(out DnsARecordData a))
129+
if (record.Type != qtype)
130130
{
131+
// A different record type (e.g. a CNAME in the chain); not our answer.
132+
continue;
133+
}
134+
135+
// The record type matches the query, so a parse failure indicates a malformed
136+
// record (e.g. an A record whose RDLENGTH is not 4) rather than NODATA.
137+
if (qtype == DnsRecordType.A)
138+
{
139+
if (!record.TryParseARecord(out DnsARecordData a))
140+
{
141+
ThrowMalformedResponse();
142+
}
131143
records.Add(new AddressRecord(a.ToIPAddress(), TimeSpan.FromSeconds(record.TimeToLive)));
132144
}
133-
else if (qtype == DnsRecordType.AAAA && record.TryParseAAAARecord(out DnsAAAARecordData aaaa))
145+
else
134146
{
147+
Debug.Assert(qtype == DnsRecordType.AAAA);
148+
if (!record.TryParseAAAARecord(out DnsAAAARecordData aaaa))
149+
{
150+
ThrowMalformedResponse();
151+
}
135152
records.Add(new AddressRecord(aaaa.ToIPAddress(), TimeSpan.FromSeconds(record.TimeToLive)));
136153
}
137154
}
@@ -376,6 +393,8 @@ private static async Task<DnsResponse> SendQuery(IList<IPEndPoint> servers, bool
376393

377394
byte[] responseBuffer = ArrayPool<byte>.Shared.Rent(MaxUdpResponseSize);
378395
Exception? lastException = null;
396+
byte[]? softErrorBuffer = null;
397+
int softErrorLength = 0;
379398

380399
foreach (IPEndPoint server in serverList)
381400
{
@@ -417,19 +436,65 @@ private static async Task<DnsResponse> SendQuery(IList<IPEndPoint> servers, bool
417436
continue;
418437
}
419438

439+
if (IsServerFailure(tcpBuffer.AsSpan(0, tcpLength)))
440+
{
441+
// The server could not answer (SERVFAIL/REFUSED); try
442+
// the next server but keep the response as a fallback.
443+
if (softErrorBuffer is null)
444+
{
445+
softErrorBuffer = tcpBuffer;
446+
softErrorLength = tcpLength;
447+
}
448+
else
449+
{
450+
ArrayPool<byte>.Shared.Return(tcpBuffer);
451+
}
452+
break;
453+
}
454+
420455
ArrayPool<byte>.Shared.Return(responseBuffer);
456+
if (softErrorBuffer is not null)
457+
{
458+
ArrayPool<byte>.Shared.Return(softErrorBuffer);
459+
}
421460
return new DnsResponse(tcpBuffer, tcpLength);
422461
}
423462

424463
lastException = tcpError;
425464
continue;
426465
}
427466

467+
if (IsServerFailure(responseBuffer.AsSpan(0, responseLength)))
468+
{
469+
// The server could not answer (SERVFAIL/REFUSED). Remember the
470+
// response and try the next server; it is returned only if no
471+
// other server produces a definitive answer.
472+
if (softErrorBuffer is null)
473+
{
474+
softErrorBuffer = responseBuffer;
475+
softErrorLength = responseLength;
476+
responseBuffer = ArrayPool<byte>.Shared.Rent(MaxUdpResponseSize);
477+
}
478+
break;
479+
}
480+
481+
if (softErrorBuffer is not null)
482+
{
483+
// A previous server returned SERVFAIL/REFUSED but this one
484+
// produced a definitive answer; discard the saved response.
485+
ArrayPool<byte>.Shared.Return(softErrorBuffer);
486+
softErrorBuffer = null;
487+
}
488+
428489
return new DnsResponse(responseBuffer, responseLength);
429490
}
430491
catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
431492
{
432493
ArrayPool<byte>.Shared.Return(responseBuffer);
494+
if (softErrorBuffer is not null)
495+
{
496+
ArrayPool<byte>.Shared.Return(softErrorBuffer);
497+
}
433498
throw;
434499
}
435500
catch (OperationCanceledException)
@@ -454,6 +519,13 @@ private static async Task<DnsResponse> SendQuery(IList<IPEndPoint> servers, bool
454519

455520
ArrayPool<byte>.Shared.Return(responseBuffer);
456521

522+
if (softErrorBuffer is not null)
523+
{
524+
// Every server that responded returned SERVFAIL/REFUSED; surface that
525+
// response so the caller sees the server's response code.
526+
return new DnsResponse(softErrorBuffer, softErrorLength);
527+
}
528+
457529
if (lastException is not null)
458530
{
459531
ExceptionDispatchInfo.Throw(lastException);
@@ -473,6 +545,12 @@ private enum ResponseValidation
473545
TcpFallback,
474546
}
475547

548+
private static bool IsServerFailure(ReadOnlySpan<byte> response)
549+
{
550+
return DnsMessageHeader.TryRead(response, out DnsMessageHeader header)
551+
&& header.ResponseCode is DnsResponseCode.ServerFailure or DnsResponseCode.Refused;
552+
}
553+
476554
private static ResponseValidation ValidateResponse(
477555
ReadOnlySpan<byte> response, ushort expectedId, string expectedName, DnsRecordType expectedType,
478556
out Exception? error)

‎src/libraries/System.Net.NameResolution/src/System/Net/ResolvConf.cs‎

Lines changed: 46 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,53 @@ internal static class ResolvConf
1313
private const string ResolvConfPath = "/etc/resolv.conf";
1414
internal const int DefaultDnsPort = 53;
1515

16+
private static readonly object s_lock = new object();
17+
private static List<IPEndPoint>? s_cachedServers;
18+
private static DateTime s_cachedWriteTimeUtc;
19+
1620
public static List<IPEndPoint> GetNameServers()
21+
{
22+
// /etc/resolv.conf is read on every query when no explicit servers are configured.
23+
// Cache the parsed result and only re-parse when the file's last-write time changes.
24+
DateTime writeTimeUtc = GetLastWriteTimeUtc();
25+
26+
lock (s_lock)
27+
{
28+
if (s_cachedServers is not null && writeTimeUtc == s_cachedWriteTimeUtc)
29+
{
30+
return s_cachedServers;
31+
}
32+
}
33+
34+
List<IPEndPoint> servers = ReadNameServers();
35+
36+
lock (s_lock)
37+
{
38+
s_cachedServers = servers;
39+
s_cachedWriteTimeUtc = writeTimeUtc;
40+
return servers;
41+
}
42+
}
43+
44+
private static DateTime GetLastWriteTimeUtc()
45+
{
46+
try
47+
{
48+
// Returns a sentinel (not an exception) when the file is missing, which is a
49+
// stable key that avoids re-reading a nonexistent file on every query.
50+
return File.GetLastWriteTimeUtc(ResolvConfPath);
51+
}
52+
catch (IOException)
53+
{
54+
return default;
55+
}
56+
catch (UnauthorizedAccessException)
57+
{
58+
return default;
59+
}
60+
}
61+
62+
private static List<IPEndPoint> ReadNameServers()
1763
{
1864
try
1965
{

‎src/libraries/System.Net.NameResolution/tests/FunctionalTests/DnsResolverLoopbackTest.cs‎

Lines changed: 57 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -191,6 +191,63 @@ public async Task ResolveAddresses_HasTtl(bool async)
191191
$"Unexpected TTL: {record.Ttl}");
192192
}
193193

194+
#if !WINDOWS
195+
// The following behaviors are specific to the managed resolver; the Windows PAL
196+
// delegates server failover and record validation to DnsQueryEx.
197+
198+
[ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsNotMobile), nameof(PlatformDetection.IsNotBrowser), nameof(PlatformDetection.IsNotWasi))]
199+
[InlineData(false)]
200+
[InlineData(true)]
201+
public async Task ResolveAddresses_ServerFailure_FailsOverToNextServer(bool async)
202+
{
203+
await using LoopbackDnsServer failing = LoopbackDnsServer.Start();
204+
string name = UniqueName("failover");
205+
failing.AddResponse(name, DnsRecordType.A, b => b.ResponseCode(DnsResponseCode.ServerFailure));
206+
_server.AddResponse(name, DnsRecordType.A, b => b.Answer(new byte[] { 10, 0, 0, 7 }, ttl: 120));
207+
208+
using DnsResolver resolver = new DnsResolver(new DnsResolverOptions
209+
{
210+
Servers = { failing.EndPoint, _server.EndPoint }
211+
});
212+
213+
DnsResult<AddressRecord> result = await ResolveAddresses(async, resolver, name, AddressFamily.InterNetwork);
214+
215+
// The first server returned SERVFAIL, so the query fell over to the second server.
216+
Assert.Equal(DnsResponseCode.NoError, result.ResponseCode);
217+
AddressRecord record = Assert.Single(result.Records);
218+
Assert.Equal("10.0.0.7", record.Address.ToString());
219+
Assert.True(failing.RequestCount > 0, "The first (failing) server should have been queried.");
220+
}
221+
222+
[ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsNotMobile), nameof(PlatformDetection.IsNotBrowser), nameof(PlatformDetection.IsNotWasi))]
223+
[InlineData(false)]
224+
[InlineData(true)]
225+
public async Task ResolveAddresses_AllServersFail_ReturnsServerFailure(bool async)
226+
{
227+
string name = UniqueName("allfail");
228+
_server.AddResponse(name, DnsRecordType.A, b => b.ResponseCode(DnsResponseCode.ServerFailure));
229+
230+
DnsResult<AddressRecord> result = await ResolveAddresses(async, Resolver, name, AddressFamily.InterNetwork);
231+
232+
// No server produced a definitive answer, so the SERVFAIL response is surfaced.
233+
Assert.Equal(DnsResponseCode.ServerFailure, result.ResponseCode);
234+
Assert.Empty(result.Records);
235+
}
236+
237+
[ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsNotMobile), nameof(PlatformDetection.IsNotBrowser), nameof(PlatformDetection.IsNotWasi))]
238+
[InlineData(false)]
239+
[InlineData(true)]
240+
public async Task ResolveAddresses_MalformedARecord_Throws(bool async)
241+
{
242+
string name = UniqueName("malformed");
243+
// An A record must carry a 4-byte address; a 3-byte RDATA is malformed.
244+
_server.AddResponse(name, DnsRecordType.A, b => b.Answer(new byte[] { 10, 0, 0 }, ttl: 120));
245+
246+
await Assert.ThrowsAsync<System.IO.InvalidDataException>(
247+
() => ResolveAddresses(async, Resolver, name, AddressFamily.InterNetwork));
248+
}
249+
#endif
250+
194251
[ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsNotMobile), nameof(PlatformDetection.IsNotBrowser), nameof(PlatformDetection.IsNotWasi))]
195252
[InlineData(false)]
196253
[InlineData(true)]

0 commit comments

Comments
 (0)