XmppFileUploadResource.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Events;
using Waher.Networking.HTTP;
using Waher.Networking.HTTP.Interfaces;
using Waher.Runtime.IO;
using Waher.Security;
 
namespace Waher.Networking.XMPP.Server.HttpFileUpload
{
    public class XmppFileUploadResource : HttpAsynchronousResource, IHttpPutRangesMethod, 
        IHttpPatchRangesMethod, IHttpGetMethod, IHttpGetRangesMethod, IFolderResource
    {
        private const int BufferSize = 32768;
 
        private readonly HttpFileUploadComponent fileUploadComponent;
        private readonly bool requireEncryption;
 
        public XmppFileUploadResource(string ResourceName, HttpFileUploadComponent FileUploadComponent, bool RequireEncryption)
            : base(ResourceName)
        {
            this.fileUploadComponent = FileUploadComponent;
            this.requireEncryption = RequireEncryption;
        }
 
        public override bool HandlesSubPaths => true;
 
        public override bool UserSessions => false;
 
        public bool AllowsPUT => true;
 
        public bool AllowsPATCH => true;
 
        public bool AllowsGET => true;
 
        public override void Validate(HttpRequest Request)
        {
            base.Validate(Request);
 
            if (!this.fileUploadComponent.TryGetFile(Request.SubPath, out string FullPath, out _, out _))
            {
                string Method = Request.Header.Method.ToUpper();
 
                if (Method == "PUT" || Method == "PATCH")
                    throw new NotFoundException("No PUT/PATCH slot found for: " + Request.SubPath);
                else
                    throw new NotFoundException("Item not found (it might have been deleted): " + Request.SubPath);
            }
 
            if (this.requireEncryption && string.Compare(Request.Header.UriScheme, "http", true) == 0)
                throw new ForbiddenException(Request, "Encryption required.");
 
            HttpRequestHeader Header = Request.Header;
            DateTimeOffset? Limit;
 
            if (Header.IfMatch is null && !(Header.IfUnmodifiedSince is null) && (Limit = Header.IfUnmodifiedSince.Timestamp).HasValue)
            {
                if (File.Exists(FullPath))
                {
                    DateTime LastModified = File.GetLastWriteTimeUtc(FullPath);
 
                    if (HttpFolderResource.GreaterOrEqual(LastModified, Limit.Value.ToUniversalTime()))
                        throw new NotModifiedException();
                }
            }
        }
 
        private class ReadProgress : IDisposableAsync
        {
            public ByteRangeInterval Next;
            public HttpResponse Response;
            public Stream f;
            public string Boundary;
            public string ContentType;
            public string FullPath;
            public long BytesLeft;
            public long TotalLength;
            public int BlockSize;
            public byte[] Buffer;
            public bool DeleteFileOnCompletion;
 
            public void Done()
            {
                if (this.DeleteFileOnCompletion)
                {
                    try
                    {
                        if (File.Exists(this.FullPath))
                            File.Delete(this.FullPath);
                    }
                    catch (Exception ex)
                    {
                        Log.Error("Unable to delete temporary file for internal transfer: " +
                            ex.Message, this.FullPath);
                    }
                }
            }
 
            public async Task BeginRead()
            {
                int NrRead;
 
                try
                {
                    do
                    {
                        while (this.BytesLeft > 0)
                        {
                            NrRead = await this.f.TryReadAllAsync(this.Buffer, 0, (int)Math.Min(this.BlockSize, this.BytesLeft));
 
                            if (NrRead <= 0)
                            {
                                await this.DisposeAsync();
                                return;
                            }
                            else
                            {
                                await this.Response.Write(false, this.Buffer, 0, NrRead);
                                this.BytesLeft -= NrRead;
                            }
                        }
 
                        if (!(this.Next is null))
                        {
                            long First;
 
                            if (this.Next.First.HasValue)
                                First = this.Next.First.Value;
                            else
                                First = this.TotalLength - this.Next.Last.Value;
 
                            this.f.Position = First;
                            this.BytesLeft = this.Next.GetIntervalLength(this.TotalLength);
 
                            await this.Response.WriteLine();
                            await this.Response.WriteLine("--" + this.Boundary);
                            await this.Response.WriteLine("Content-Type: " + this.ContentType);
                            await this.Response.WriteLine("Content-Range: " + ContentByteRangeInterval.ContentRangeToString(First, First + this.BytesLeft - 1, this.TotalLength));
                            await this.Response.WriteLine();
 
                            this.Next = this.Next.Next;
                        }
                    }
                    while (this.BytesLeft > 0);
 
                    if (!string.IsNullOrEmpty(this.Boundary))
                    {
                        await this.Response.WriteLine();
                        await this.Response.WriteLine("--" + this.Boundary + "--");
                    }
 
                    await this.DisposeAsync();
 
                    this.Done();    // Do not call if transfer is not complete, or an error occurs.
                }
                catch (Exception ex)
                {
                    try
                    {
                        if (!this.Response.HeaderSent)
                            await this.Response.SendResponse(ex);
                        else
                            await this.Response.Flush(true);
 
                        await this.Response.DisposeAsync();
                        this.Response = null;
 
                        await this.DisposeAsync();
                    }
                    catch (Exception)
                    {
                        // Ignore
                    }
                }
            }
 
            public async Task DisposeAsync()
            {
                if (!(this.Response is null))
                {
                    await this.Response.SendResponse();
                    this.Response = null;
                }
 
                if (!(this.f is null))
                {
                    await this.f.FlushAsync();
                    this.f.Dispose();
                    this.f = null;
                }
            }
 
            public void Dispose()
            {
                Task _ = this.DisposeAsync();
            }
        }
 
        private readonly Dictionary<string, CacheRec> cacheInfo = new Dictionary<string, CacheRec>();
 
        private class CacheRec
        {
            public DateTime LastModified;
            public string ETag;
        }
 
        public async Task GET(HttpRequest Request, HttpResponse Response)
        {
            if (!this.fileUploadComponent.TryGetFile(Request.SubPath, out string FullPath,
                out string ContentType, out FilePurpose Purpose))
            {
                await Response.SendResponse(new NotFoundException());
                return;
            }
 
            if (Purpose == FilePurpose.InternalTransfer &&
                !InternalTransferAccess.IsInternal(Request))
            {
                await Response.SendResponse(new ForbiddenException("Internal transfer files not accessible by remote parties."));
                return;
            }
 
            if (!File.Exists(FullPath))
            {
                await Response.SendResponse(new NotFoundException());
                return;
            }
 
            DateTime LastModified = File.GetLastWriteTimeUtc(FullPath);
            CacheRec Rec;
 
            Rec = this.CheckCacheHeaders(FullPath, LastModified, Request);
            if (Rec is null)
            {
                await Response.SendResponse(new NotModifiedException());
                return;
            }
 
            if (!(Request.Header.Accept is null))
            {
                if (!Request.Header.Accept.IsAcceptable(ContentType))
                {
                    await Response.SendResponse(new NotAcceptableException());
                    return;
                }
            }
 
            Stream f = File.OpenRead(FullPath);
 
            await SendResponse(f, FullPath, ContentType, Rec.ETag, LastModified, Response, Purpose);
        }
 
        private static async Task SendResponse(Stream f, string FullPath, string ContentType, 
            string ETag, DateTime LastModified, HttpResponse Response, FilePurpose Purpose)
        {
            ReadProgress Progress = new ReadProgress()
            {
                Response = Response,
                f = f ?? File.OpenRead(FullPath),
                FullPath = FullPath,
                Next = null,
                Boundary = null,
                ContentType = null,
                DeleteFileOnCompletion = Purpose == FilePurpose.InternalTransfer
            };
            Progress.BytesLeft = Progress.TotalLength = Progress.f.Length;
            Progress.BlockSize = (int)Math.Min(BufferSize, Progress.BytesLeft);
            Progress.Buffer = new byte[Progress.BlockSize];
 
            Response.ContentType = ContentType;
            Response.ContentLength = Progress.TotalLength;
 
            Response.SetHeader("ETag", ETag);
            Response.SetHeader("Last-Modified", CommonTypes.EncodeRfc822(LastModified));
 
            if (Response.OnlyHeader || Progress.TotalLength == 0)
            {
                await Response.SendResponse();
                await Progress.DisposeAsync();
 
                if (Progress.TotalLength == 0)
                    Progress.Done();
            }
            else
            {
                Task _ = Progress.BeginRead();
            }
        }
 
        private CacheRec CheckCacheHeaders(string FullPath, DateTime LastModified, HttpRequest Request)
        {
            string CacheKey = FullPath.ToLower();
            HttpRequestHeader Header = Request.Header;
            CacheRec Rec;
            DateTimeOffset? Limit;
 
            lock (this.cacheInfo)
            {
                if (this.cacheInfo.TryGetValue(CacheKey, out Rec))
                {
                    if (Rec.LastModified != LastModified)
                    {
                        this.cacheInfo.Remove(CacheKey);
                        Rec = null;
                    }
                }
            }
 
            if (Rec is null)
            {
                Rec = new CacheRec()
                {
                    LastModified = LastModified,
                };
 
                using (FileStream fs = File.OpenRead(FullPath))
                {
                    Rec.ETag = Hashes.ComputeSHA1HashString(fs);
                }
 
                lock (this.cacheInfo)
                {
                    this.cacheInfo[CacheKey] = Rec;
                }
            }
 
            if (!(Header.IfNoneMatch is null))
            {
                if (Header.IfNoneMatch.Value == Rec.ETag)
                    return null;
            }
            else if (!(Header.IfModifiedSince is null))
            {
                if ((Limit = Header.IfModifiedSince.Timestamp).HasValue &&
                    HttpFolderResource.LessOrEqual(LastModified, Limit.Value.ToUniversalTime()))
                {
                    return null;
                }
            }
 
            return Rec;
        }
 
        public async Task GET(HttpRequest Request, HttpResponse Response, ByteRangeInterval FirstInterval)
        {
            if (!this.fileUploadComponent.TryGetFile(Request.SubPath, out string FullPath,
                out string ContentType, out FilePurpose Purpose))
            {
                await Response.SendResponse(new NotFoundException());
                return;
            }
 
            if (Purpose == FilePurpose.InternalTransfer &&
                !(Request.User is InternalTransferAccess.InternalUser))
            {
                await Response.SendResponse(new ForbiddenException("Internal transfer files not accessible by remote parties."));
                return;
            }
 
            if (!File.Exists(FullPath))
            {
                await Response.SendResponse(new NotFoundException());
                return;
            }
 
            HttpRequestHeader Header = Request.Header;
            DateTime LastModified = File.GetLastWriteTimeUtc(FullPath);
            DateTimeOffset? Limit;
            CacheRec Rec;
 
            if (!(Header.IfRange is null) && (Limit = Header.IfRange.Timestamp).HasValue &&
                !HttpFolderResource.LessOrEqual(LastModified, Limit.Value.ToUniversalTime()))
            {
                Response.StatusCode = 200;
                Response.StatusMessage = "OK";
                await this.GET(Request, Response);    // No ranged request.
                return;
            }
 
            Rec = this.CheckCacheHeaders(FullPath, LastModified, Request);
            if (Rec is null)
            {
                await Response.SendResponse(new NotModifiedException());
                return;
            }
 
            if (!(Request.Header.Accept is null))
            {
                if (!Request.Header.Accept.IsAcceptable(ContentType))
                {
                    await Response.SendResponse(new NotAcceptableException());
                    return;
                }
            }
 
            Stream f = File.OpenRead(FullPath);
 
            ReadProgress Progress = new ReadProgress()
            {
                Response = Response,
                DeleteFileOnCompletion = false,
                f = f ?? File.OpenRead(FullPath)
            };
 
            ByteRangeInterval Interval = FirstInterval;
            Progress.TotalLength = Progress.f.Length;
 
            long i = 0;
            long j;
            long First;
 
            if (FirstInterval.First.HasValue)
                First = FirstInterval.First.Value;
            else
                First = Progress.TotalLength - FirstInterval.Last.Value;
 
            Progress.f.Position = First;
            Progress.BytesLeft = Interval.GetIntervalLength(Progress.TotalLength);
            Progress.Next = Interval.Next;
 
            while (!(Interval is null))
            {
                j = Interval.GetIntervalLength(Progress.TotalLength);
                if (j > i)
                    i = j;
 
                Interval = Interval.Next;
            }
 
            Progress.BlockSize = (int)Math.Min(BufferSize, i);
            Progress.Buffer = new byte[Progress.BlockSize];
 
            if (FirstInterval.Next is null)
            {
                Progress.Boundary = null;
                Progress.ContentType = null;
 
                Response.ContentType = ContentType;
                Response.ContentLength = FirstInterval.GetIntervalLength(Progress.f.Length);
                Response.SetHeader("Content-Range", ContentByteRangeInterval.ContentRangeToString(First, First + Progress.BytesLeft - 1, Progress.TotalLength));
            }
            else
            {
                Progress.Boundary = Guid.NewGuid().ToString().Replace("-", string.Empty);
                Progress.ContentType = ContentType;
 
                Response.ContentType = "multipart/byteranges; boundary=" + Progress.Boundary;
                // chunked transfer encoding will be used
            }
 
            Response.SetHeader("ETag", Rec.ETag);
            Response.SetHeader("Last-Modified", CommonTypes.EncodeRfc822(LastModified));
 
            if (Response.OnlyHeader || Progress.BytesLeft == 0)
            {
                await Response.SendResponse();
                await Progress.DisposeAsync();
            }
            else
            {
                if (!(FirstInterval.Next is null))
                {
                    await Response.WriteLine();
                    await Response.WriteLine("--" + Progress.Boundary);
                    await Response.WriteLine("Content-Type: " + Progress.ContentType);
                    await Response.WriteLine("Content-Range: " + ContentByteRangeInterval.ContentRangeToString(First, First + Progress.BytesLeft - 1, Progress.TotalLength));
                    await Response.WriteLine();
                }
 
                Task _ = Progress.BeginRead();
            }
        }
 
        public Task PATCH(HttpRequest Request, HttpResponse Response, ContentByteRangeInterval Interval)
        {
            return this.PUT(Request, Response, Interval);
        }
 
        public async Task PUT(HttpRequest Request, HttpResponse Response, ContentByteRangeInterval Interval)
        {
            try
            {
                if (!Request.HasData)
                    throw new BadRequestException();
 
                string Key = Request.Header["X-Key"];
 
                if (!await this.fileUploadComponent.DataUploaded(Request.SubPath, Key,
                    Request.DataStream, Interval, Request.Header.ContentType?.Value,
                    Request.RemoteEndPoint))
                {
                    throw new ForbiddenException(Request, "Upload rejected.");
                }
 
                Response.StatusCode = 201;
                Response.StatusMessage = "Created";
                await Response.SendResponse();
            }
            catch (Exception ex)
            {
                await Response.SendResponse(ex);
            }
        }
 
        public bool TryGetFileName(string SubPath, string Host, bool MustExist,
            out string FileName)
        {
            if (this.fileUploadComponent.TryGetFile(SubPath, out string FullPath, out _, out _))
            {
                if (!MustExist || File.Exists(FullPath))
                {
                    FileName = FullPath;
                    return true;
                }
            }
 
            FileName = null;
            return false;
        }
 
    }
}