public static RecordType ParseShortString(string s)
{
if (String.IsNullOrEmpty(s))
{
throw new ArgumentOutOfRangeException(nameof(s));
}
RecordType recordType;
if (EnumHelper <RecordType> .TryParse(s, true, out recordType))
{
return(recordType);
}
if (s.StartsWith("TYPE", NetStandardExtensionFixes.GetDefaultIgnoreCaseComparison()))
{
ushort classValue;
if (UInt16.TryParse(s.Substring(4), out classValue))
{
return((RecordType)classValue);
}
}
throw new ArgumentOutOfRangeException(nameof(s));
}
public static bool TryParseShortString(string s, out RecordType recordType)
{
if (String.IsNullOrEmpty(s))
{
recordType = RecordType.Invalid;
return(false);
}
if (EnumHelper <RecordType> .TryParse(s, true, out recordType))
{
return(true);
}
if (s.StartsWith("TYPE", NetStandardExtensionFixes.GetDefaultIgnoreCaseComparison()))
{
ushort classValue;
if (UInt16.TryParse(s.Substring(4), out classValue))
{
recordType = (RecordType)classValue;
return(true);
}
}
recordType = RecordType.Invalid;
return(false);
}
public static bool TryParseShortString(string s, out RecordClass recordClass, bool allowAny = true)
{
if (String.IsNullOrEmpty(s))
{
recordClass = RecordClass.Invalid;
return(false);
}
switch (s.ToUpperInvariant())
{
case "IN":
recordClass = RecordClass.INet;
return(true);
case "CH":
recordClass = RecordClass.Chaos;
return(true);
case "HS":
recordClass = RecordClass.Hesiod;
return(true);
case "NONE":
recordClass = RecordClass.None;
return(true);
case "*":
if (allowAny)
{
recordClass = RecordClass.Any;
return(true);
}
else
{
recordClass = RecordClass.Invalid;
return(false);
}
default:
if (s.StartsWith("CLASS", NetStandardExtensionFixes.GetDefaultIgnoreCaseComparison()))
{
ushort classValue;
if (UInt16.TryParse(s.Substring(5), out classValue))
{
recordClass = (RecordClass)classValue;
return(true);
}
}
recordClass = RecordClass.Invalid;
return(false);
}
}
internal override void ParseRecordData(DomainName origin, string[] stringRepresentation)
{
if (stringRepresentation.Length != 1)
{
throw new FormatException();
}
if (!stringRepresentation[0].StartsWith("0x", NetStandardExtensionFixes.GetDefaultIgnoreCaseComparison()))
{
throw new FormatException();
}
RecordData = stringRepresentation[0].Substring(2).Replace(".", String.Empty).FromBase16String();
}
internal override void ParseRecordData(DomainName origin, string[] stringRepresentation)
{
var groups = _parserRegex
.Match(String.Join(" ", stringRepresentation))
.Groups;
bool latNegative = groups["lat"].Value.Equals("S", NetStandardExtensionFixes.GetDefaultIgnoreCaseComparison());
Latitude = new Degree(latNegative, groups["latd"].Value, groups["latm"].Value, groups["lats"].Value, groups["latms"].Value);
bool longNegative = groups["long"].Value.Equals("W", NetStandardExtensionFixes.GetDefaultIgnoreCaseComparison());
Longitude = new Degree(longNegative, groups["longd"].Value, groups["longm"].Value, groups["longs"].Value, groups["longms"].Value);
Altitude = Double.Parse(groups["alt"].Value, CultureInfo.InvariantCulture);
Size = String.IsNullOrEmpty(groups["size"].Value) ? 1 : Double.Parse(groups["size"].Value, CultureInfo.InvariantCulture);
HorizontalPrecision = String.IsNullOrEmpty(groups["hp"].Value) ? 10000 : Double.Parse(groups["hp"].Value, CultureInfo.InvariantCulture);
VerticalPrecision = String.IsNullOrEmpty(groups["vp"].Value) ? 10 : Double.Parse(groups["vp"].Value, CultureInfo.InvariantCulture);
}
private static List <DnsRecordBase> ParseRecords(StreamReader reader, DomainName origin, int ttl, DnsRecordBase lastRecord)
{
List <DnsRecordBase> records = new List <DnsRecordBase>();
while (!reader.EndOfStream)
{
string line = ReadRecordLine(reader);
if (!String.IsNullOrEmpty(line))
{
string[] parts = _lineSplitterRegex.Matches(line).Cast <Match>().Select(x => x.Groups.Cast <Group>().Last(g => g.Success).Value.FromMasterfileLabelRepresentation()).ToArray();
if (parts[0].Equals("$origin", NetStandardExtensionFixes.GetDefaultIgnoreCaseComparison()))
{
origin = DomainName.ParseFromMasterfile(parts[1]);
}
if (parts[0].Equals("$ttl", NetStandardExtensionFixes.GetDefaultIgnoreCaseComparison()))
{
ttl = Int32.Parse(parts[1]);
}
if (parts[0].Equals("$include", NetStandardExtensionFixes.GetDefaultIgnoreCaseComparison()))
{
FileStream fileStream = reader.BaseStream as FileStream;
if (fileStream == null)
{
throw new NotSupportedException("Includes only supported when loading files");
}
// ReSharper disable once AssignNullToNotNullAttribute
string path = Path.Combine(new FileInfo(fileStream.Name).DirectoryName, parts[1]);
DomainName includeOrigin = (parts.Length > 2) ? DomainName.ParseFromMasterfile(parts[2]) : origin;
#if NETSTANDARD
using (var newFileStreamPath = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read))
using (StreamReader includeReader = new StreamReader(newFileStreamPath))
#else
using (StreamReader includeReader = new StreamReader(path))
#endif
{
records.AddRange(ParseRecords(includeReader, includeOrigin, ttl, lastRecord));
}
}
else
{
string domainString;
RecordType recordType;
RecordClass recordClass;
int recordTtl;
string[] rrData;
if (Int32.TryParse(parts[0], out recordTtl))
{
// no domain, starts with ttl
if (RecordClassHelper.TryParseShortString(parts[1], out recordClass, false))
{
// second is record class
domainString = null;
recordType = RecordTypeHelper.ParseShortString(parts[2]);
rrData = parts.Skip(3).ToArray();
}
else
{
// no record class
domainString = null;
recordClass = RecordClass.Invalid;
recordType = RecordTypeHelper.ParseShortString(parts[1]);
rrData = parts.Skip(2).ToArray();
}
}
else if (RecordClassHelper.TryParseShortString(parts[0], out recordClass, false))
{
// no domain, starts with record class
if (Int32.TryParse(parts[1], out recordTtl))
{
// second is ttl
domainString = null;
recordType = RecordTypeHelper.ParseShortString(parts[2]);
rrData = parts.Skip(3).ToArray();
}
else
{
// no ttl
recordTtl = 0;
domainString = null;
recordType = RecordTypeHelper.ParseShortString(parts[1]);
rrData = parts.Skip(2).ToArray();
}
}
else if (RecordTypeHelper.TryParseShortString(parts[0], out recordType))
{
// no domain, start with record type
recordTtl = 0;
recordClass = RecordClass.Invalid;
domainString = null;
rrData = parts.Skip(2).ToArray();
}
else
{
domainString = parts[0];
if (Int32.TryParse(parts[1], out recordTtl))
{
// domain, second is ttl
if (RecordClassHelper.TryParseShortString(parts[2], out recordClass, false))
{
// third is record class
recordType = RecordTypeHelper.ParseShortString(parts[3]);
rrData = parts.Skip(4).ToArray();
}
else
{
// no record class
recordClass = RecordClass.Invalid;
recordType = RecordTypeHelper.ParseShortString(parts[2]);
rrData = parts.Skip(3).ToArray();
}
}
else if (RecordClassHelper.TryParseShortString(parts[1], out recordClass, false))
{
// domain, second is record class
if (Int32.TryParse(parts[2], out recordTtl))
{
// third is ttl
recordType = RecordTypeHelper.ParseShortString(parts[3]);
rrData = parts.Skip(4).ToArray();
}
else
{
// no ttl
recordTtl = 0;
recordType = RecordTypeHelper.ParseShortString(parts[2]);
rrData = parts.Skip(3).ToArray();
}
}
else
{
// domain with record type
recordType = RecordTypeHelper.ParseShortString(parts[1]);
recordTtl = 0;
recordClass = RecordClass.Invalid;
rrData = parts.Skip(2).ToArray();
}
}
DomainName domain;
if (String.IsNullOrEmpty(domainString))
{
domain = lastRecord.Name;
}
else if (domainString == "@")
{
domain = origin;
}
else if (domainString.EndsWith("."))
{
domain = DomainName.ParseFromMasterfile(domainString);
}
else
{
domain = DomainName.ParseFromMasterfile(domainString) + origin;
}
if (recordClass == RecordClass.Invalid)
{
recordClass = lastRecord.RecordClass;
}
if (recordType == RecordType.Invalid)
{
recordType = lastRecord.RecordType;
}
if (recordTtl == 0)
{
recordTtl = ttl;
}
else
{
ttl = recordTtl;
}
lastRecord = DnsRecordBase.Create(recordType);
lastRecord.RecordType = recordType;
lastRecord.Name = domain;
lastRecord.RecordClass = recordClass;
lastRecord.TimeToLive = recordTtl;
if ((rrData.Length > 0) && (rrData[0] == @"\#"))
{
lastRecord.ParseUnknownRecordData(rrData);
}
else
{
lastRecord.ParseRecordData(origin, rrData);
}
records.Add(lastRecord);
}
}
}
return(records);
}
