Domain.cs

Go to the documentation of this file.

using System;
 
namespace Hermod.Core.Accounts {
 
    using Exceptions;
    using Serilog.Events;
    using System.Net;
    using System.Text.RegularExpressions;
 
    public partial class Domain {
 
        public const string IanaValidTldListUrl = "https://data.iana.org/TLD/tlds-alpha-by-domain.txt";
 
        [GeneratedRegex(@"(?:[a-z0-9-](?:[a-z0-9-]{0,61}[a-z0-9-])?\.)+[a-z0-9-][a-z0-9-]{0,61}[a-z0-9-]", RegexOptions.Compiled | RegexOptions.IgnoreCase)]
        public static partial Regex DomainRegex();
 
        public static List<string> ValidTlds { get; } = new List<string>();
 
        public Domain(int id, string tld, string domainName, params DomainUser[] users) {
            if (string.IsNullOrEmpty(tld) || string.IsNullOrEmpty(domainName)) { throw new MalformedDomainException($"{ domainName }.{ tld }"); }
 
            Id = id;
            Tld = tld;
            DomainName = domainName;
            DomainUsers = users.ToList();
        }
 
        public Domain(int id, string fqdn, params DomainUser[] users) {
            if (string.IsNullOrEmpty(fqdn) || !fqdn.Contains('.')) { throw new MalformedDomainException(fqdn); }
 
            Id = id;
            var splits = fqdn.Split('.').Where(x => x != ".").ToArray();
            Tld = splits[0];
            DomainName = string.Join('.', splits[1..]);
            DomainUsers = users.ToList();
        }
 
        public Domain(Domain domain, bool includeUsers = false) {
            Id = domain.Id;
            Tld = domain.Tld;
            DomainName = domain.DomainName;
 
            if (includeUsers) {
                DomainUsers = new List<DomainUser>(domain.DomainUsers.ConvertAll(x => x)); // shallow copy
            } else {
                DomainUsers = new List<DomainUser>();
            }
        }
 
        public int Id { get; set; }
 
        public string Tld { get; set; }
 
        public string DomainName { get; set; }
 
        public List<DomainUser> DomainUsers { get; set; }
 
        public static bool IsValidDomain(string fqdn, out int? tldLevels, out string? tld, out string? domain) {
            tldLevels = null;
            tld = null;
            domain = null;
 
            if (
                string.IsNullOrEmpty(fqdn)          ||
                string.IsNullOrWhiteSpace(fqdn)     ||
                !IsFqdnInBounds(fqdn)               ||
                fqdn.Any(ContainsInvalidChars)      ||
                !DomainRegex().IsMatch(fqdn)
            ) { return false; }
 
            fqdn = fqdn.ToLowerInvariant();
 
            var containsValidTld = false;
            var domainLevels = fqdn.Split('.').Where(x => x != ".").ToList();
            var firstNonTopLevel = -1;
 
            // Determine whether or not the fqdn contains valid TLDs.
            // Non-valid domains will also be accepted by Hermod
            for (int i = 0; i < domainLevels.Count; i++) {
                if (!IsValidTld(domainLevels.ElementAt(i))) {
                    firstNonTopLevel = i;
                    break;
                }
 
                containsValidTld = true;
            }
 
            if (firstNonTopLevel == 0) {
                // We've found a domain with invalid TLDs.
                // For Hermod's sake, this is perfectly acceptable!
                // We'll just use the first level as the TLD.
                firstNonTopLevel = 1;
            }
 
            tldLevels = firstNonTopLevel;
            tld = string.Join('.', domainLevels.GetRange(0, firstNonTopLevel));
            domain = string.Join('.', domainLevels.GetRange(firstNonTopLevel, domainLevels.Count - firstNonTopLevel));
 
            return containsValidTld;
        }
 
        private static bool ContainsInvalidChars(char c) => !char.IsDigit(c) && !char.IsLetter(c) && c != '-' && c != '.';
 
        public static bool IsFqdnInBounds(string fqdn) => fqdn.Length is (<= 255) and (> 0);
 
        public static bool IsValidTld(string tld) {
            if (ValidTlds.Count == 0 && !DownloadCurrentValidTldListFromIana()) { return false; }
 
            return ValidTlds.Contains(tld);
        }
 
        public static bool DownloadCurrentValidTldListFromIana() {
            using var httpClient = new HttpClient { };
            using var httpResponse = httpClient.GetAsync(IanaValidTldListUrl).GetAwaiter().GetResult();
 
            if (httpResponse is null) { return ValidTlds.Count > 0; }
 
            using (var sReader = new StreamReader(httpResponse.Content.ReadAsStream())) {
                ValidTlds.Clear();
                while (sReader.Peek() != -1) {
                    var line = sReader.ReadLine();
                    if (line is null) { break; }
                    if (line.StartsWith("#") || line.Length == 0) { continue; }
 
                    ValidTlds.Add(line.ToLowerInvariant());
                }
            }
 
            return ValidTlds.Count > 0;
        }
 
        public static async Task<bool> DownloadCurrentValidTldListFromIanaAsync() {
            using var httpClient = new HttpClient { };
            using var httpResponse = await httpClient.GetAsync(IanaValidTldListUrl);
 
            if (httpResponse is null) { return ValidTlds.Count > 0; }
 
            using (var sReader = new StreamReader(await httpResponse.Content.ReadAsStreamAsync())) {
                ValidTlds.Clear();
                while (sReader.Peek() != -1) {
                    var line = await sReader.ReadLineAsync();
                    if (line is null) { break; }
                    if (line.StartsWith("#") || line.Length == 0) { continue; }
 
                    ValidTlds.Add(line.ToLowerInvariant());
                }
            }
 
            return ValidTlds.Count > 0;
        }
 
    }
}