DnsOverHttpsResource.cs

using System;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Networking.DNS.Communication;
using Waher.Networking.HTTP;
using Waher.Runtime.Inventory;
 
namespace Waher.Networking.DNS.HTTPS
{
    public class DnsOverHttpsResource : HttpSynchronousResource, IHttpGetMethod, IHttpPostMethod
    {
        public const string ContentType = "application/dns-message";
 
        public DnsOverHttpsResource()
            : this("/dns")
        {
        }
 
        public DnsOverHttpsResource(string ResourceName)
            : base(ResourceName)
        {
        }
 
        public override bool HandlesSubPaths => false;
 
        public override bool UserSessions => false;
 
        public bool AllowsGET => true;
 
        public bool AllowsPOST => true;
 
        public async Task GET(HttpRequest Request, HttpResponse Response)
        {
            try
            {
                if (!Request.Header.TryGetQueryParameter("dns", out string s))
                    await Response.SendResponse(new BadRequestException("Request lacking dns query parameter."));
                else if (Request.Header.Accept is null || Request.Header.Accept.IsAcceptable(ContentType))
                {
                    byte[] Bin = Base64Url.Decode(s);
                    await this.Process(Bin, Response, true);
                }
                else
                    await Response.SendResponse(new NotAcceptableException("Only acceptable encoding is DNS encoding."));
            }
            catch (Exception)
            {
                await Response.SendResponse(new BadRequestException("Invalid request."));
            }
        }
 
        public async Task POST(HttpRequest Request, HttpResponse Response)
        {
            try
            {
                if (!Request.HasData || string.Compare(Request.Header.ContentType?.Type, ContentType, true) != 0)
                    await Response.SendResponse(new UnsupportedMediaTypeException("DNS encoded content expected."));
                else if (string.Compare(Request.Header.UriScheme, "http", true) == 0)
                    await Response.SendResponse(new BadRequestException("Unencrypted transport not permitted."));
                else
                {
                    int c = (int)Request.DataStream.Length;
                    byte[] Bin = new byte[c];
                    await Request.DataStream.ReadAllAsync(Bin, 0, c);
                    
                    await this.Process(Bin, Response, false);
                }
            }
            catch (Exception)
            {
                await Response.SendResponse(new BadRequestException("Invalid request."));
            }
        }
 
        private async Task Process(byte[] ReqBin, HttpResponse Response, bool Cache)
        {
            DnsMessage Msg = new DnsMessage(ReqBin);
 
            foreach (Question Question in Msg.Questions)
            {
                DnsResponse DnsResponse = await DnsResolver.Query(Question.QNAME, Question.QTYPE, Question.QCLASS);
                if (DnsResponse is null)
                    await Response.SendResponse(new BadRequestException("Unable to resolve query."));
                else
                {
                    byte[] RespBin = (byte[])DnsResponse.Raw.Clone();
 
                    RespBin[0] = ReqBin[0];     // Use same ID as in request.
                    RespBin[1] = ReqBin[1];
 
                    Response.StatusCode = 200;
                    Response.ContentType = ContentType;
 
                    if (Cache)
                    {
                        int Seconds = (int)Math.Ceiling((DnsResponse.Expires - DateTime.Now).TotalSeconds);
                        if (Seconds > 0)
                            Response.SetHeader("Cache-Control", "max-age=" + Seconds.ToString());
                    }
 
                    await Response.Write(RespBin);
                }
                return;
            }
 
            await Response.SendResponse(new BadRequestException("Request lacking dns query parameter."));
        }
 
    }
}