BlockResource.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.Content.Json;
using Waher.Content.Xml;
using Waher.Content.Xml.Text;
using Waher.Networking.HTTP;
using Waher.Networking.HTTP.HeaderFields;
using Waher.Persistence;
using Waher.Persistence.NeuroLedger;
using Waher.Persistence.NeuroLedger.Registry;
using Waher.Persistence.Serialization;
using Waher.Runtime.IO;
using Waher.Script;
using Waher.Security;
 
namespace Waher.Networking.XMPP.NeuroLedger.Web
{
    public class BlockResource : HttpAsynchronousResource, IHttpGetMethod
    {
        public const string ErrorMsg_BlockFileHasBeenRemoved = "Block file has been removed.";
 
        private readonly NeuroLedgerProvider provider;
        private readonly NeuroLedgerClient nlClient;
        private readonly XmppClient client;
        private readonly HttpServer webServer;
        private readonly string userVariable;
        private readonly string[] userPrivileges;
 
        public BlockResource(string ResourceName, NeuroLedgerProvider Provider, XmppClient Client, NeuroLedgerClient NLClient,
            HttpServer WebServer, string UserVariable, params string[] UserPrivileges)
            : base(ResourceName)
        {
            this.client = Client;
            this.nlClient = NLClient;
            this.provider = Provider;
            this.webServer = WebServer;
            this.userVariable = UserVariable;
            this.userPrivileges = UserPrivileges;
        }
 
        public override bool HandlesSubPaths => true;
 
        public override bool UserSessions => false;
 
        public bool AllowsGET => true;
 
        public async Task GET(HttpRequest Request, HttpResponse Response)
        {
            byte[] Digest;
 
            try
            {
                Digest = Base64Url.Decode(Request.SubPath[1..]);
            }
            catch (Exception)
            {
                await Response.SendResponse(new BadRequestException("Invalid block digest."));
                return;
            }
 
            if (this.nlClient.ClientDisposed)
            {
                await Response.SendResponse(new ServiceUnavailableException("Service is closing down."));
                return;
            }
 
            BlockReference Ref = await NeuroLedgerProvider.FindReference(Digest);
            if (Ref is null)
            {
                await Response.SendResponse(new NotFoundException("Block not found."));
                return;
            }
 
            if (Ref.AccessDenied && Ref.Creator != this.provider.ExternalIdentity)
            {
                await Response.SendResponse(new FailedDependencyException("Access to block was denied by creator or block source."));
                return;
            }
 
            string s = Request.RemoteEndPoint;
            int i = s.IndexOf('/');
            if (i > 0)
                s = s[..i];
 
            RosterItem Item = this.client[s];
 
            if (Item is null)
            {
                string HttpSessionID = GetSessionId(Request, Response);
 
                if (string.IsNullOrEmpty(HttpSessionID))
                {
                    await Response.SendResponse(new ForbiddenException(Request, "Access to block not granted: Accessing blocks can only be done by approved peers, or via the administrative portal."));
                    return;
                }
                else
                {
                    Variables Session = this.webServer.GetSession(HttpSessionID, false);
                    if (Session is null ||
                        !Session.TryGetVariable(this.userVariable, out Variable v) ||
                        !(v.ValueObject is IUser User))
                    {
                        await Response.SendResponse(new ForbiddenException(Request, "Access to block not granted: User needs to be logged in."));
                        return;
                    }
                    else
                    {
                        foreach (string Privilege in this.userPrivileges)
                        {
                            if (!User.HasPrivilege(Privilege))
                            {
                                await Response.SendResponse(new ForbiddenException(Request, "Access to block not granted: User lacks sufficient privileges."));
                                return;
                            }
                        }
                    }
                }
            }
            else
            {
                if (Item.State != SubscriptionState.Both && Item.State != SubscriptionState.From)
                {
                    await Response.SendResponse(new ForbiddenException(Request, "Access to block not granted: Presence subscription not approved."));
                    return;
                }
                else if (!Item.IsInGroup(Ref.Collection))
                {
                    await Response.SendResponse(new ForbiddenException(Request, "Access to block not granted: Peer is not authorized to access collection " + Ref.Collection + "."));
                    return;
                }
            }
 
            Task _ = this.ProcessRequest(Request.Header.Accept, Response, Ref);
        }
 
        public async Task ProcessRequest(HttpFieldAccept Accept, HttpResponse Response, BlockReference Ref)
        {
            try
            {
                if (this.nlClient.ClientDisposed)
                {
                    await Response.SendResponse(new ServiceUnavailableException("Service is closing down."));
                    return;
                }
 
                string Alternative = Accept?.GetBestAlternative("binary", "application/octet-stream", 
                    XmlCodec.DefaultContentType, XmlCodec.SchemaContentType,
                    JsonCodec.DefaultContentType, "text/x-json") ?? "application/octet-stream";
 
                string FileName = this.provider.GetFullFileName(Ref.FileName);
 
                if (string.IsNullOrEmpty(Ref.FileName) || !File.Exists(FileName))
                {
                    if (!(Ref.Sources is null))
                    {
                        foreach (string Source in Ref.Sources)
                        {
                            if (this.nlClient.ClientDisposed)
                            {
                                await Response.SendResponse(new ServiceUnavailableException("Service is closing down."));
                                return;
                            }
 
                            if (await this.nlClient.RetrieveBlock(Ref, Source, null, true))
                                break;
                        }
                    }
 
                    if (Ref.AccessDenied && Ref.Creator != this.provider.ExternalIdentity)
                    {
                        await Response.SendResponse(new FailedDependencyException("Access to block was denied by creator or block source."));
                        return;
                    }
 
                    FileName = this.provider.GetFullFileName(Ref.FileName);
                    if (string.IsNullOrEmpty(Ref.FileName) || !File.Exists(FileName))
                    {
                        if (Ref.Creator == this.provider.ExternalIdentity)
                        {
                            await Database.Delete(Ref);
                            await Response.SendResponse(new NotFoundException(ErrorMsg_BlockFileHasBeenRemoved));
                            return;
                        }
                        else
                        {
                            await Response.SendResponse(new FailedDependencyException("Unable to download block from creator."));
                            return;
                        }
                    }
                }
 
                switch (Alternative)
                {
                    case "binary":
                    case "application/octet-stream":
                        Response.StatusCode = 200;
                        Response.StatusMessage = "OK";
                        Response.ContentType = Alternative;
 
                        using (Stream f = BlockReader.GetStream(FileName, this.provider))
                        {
                            MemoryStream Header = new MemoryStream();
                            int CollectionLen = f.ReadByte();
                            Header.WriteByte((byte)CollectionLen);
 
                            if (CollectionLen == 0)
                                CollectionLen = 256;
 
                            byte[] CollectionBin = await f.ReadAllAsync(CollectionLen);
 
                            Header.Write(CollectionBin, 0, CollectionLen);
 
                            string CollectionName = Encoding.UTF8.GetString(CollectionBin);
                            Response.SetHeader("X-Collection", CollectionName);
 
                            int SigLen = f.ReadByte();
                            Header.WriteByte((byte)SigLen);
 
                            if (SigLen == 0)
                                SigLen = 256;
 
                            byte[] Signature = await f.ReadAllAsync(SigLen);
 
                            Header.Write(Signature, 0, SigLen);
                            Response.SetHeader("X-Signature", Convert.ToBase64String(Signature));
 
                            byte[] ContentLen = await f.ReadAllAsync(8);
 
                            Header.Write(ContentLen, 0, 8);
 
                            long InputLength = BitConverter.ToInt64(ContentLen, 0);
                            byte[] Buf = Header.ToArray();
 
                            Response.ContentLength = Header.Length + InputLength;
                            await Response.Write(true, Buf, 0, Buf.Length);
 
                            Buf = new byte[(int)Math.Min(32768, InputLength)];
 
                            while (InputLength > 0)
                            {
                                int i = (int)Math.Min(32768, InputLength);
 
                                await f.ReadAllAsync(Buf, 0, i);
 
                                await Response.Write(false, Buf, 0, i);
                                InputLength -= i;
                            }
                        }
                        break;
 
                    case XmlCodec.DefaultContentType:
                    case XmlCodec.SchemaContentType:
                        XmlWriterSettings Settings = XML.WriterSettings(true, true);
                        StringBuilder Xml = new StringBuilder();
                        XmlWriter w = XmlWriter.Create(Xml, Settings);
 
                        w.WriteStartDocument();
                        w.WriteStartElement("Block", "http://waher.se/NLB");
                        w.WriteAttributeString("digest", Convert.ToBase64String(Ref.Digest));
                        w.WriteAttributeString("status", Ref.Status.ToString());
                        w.WriteAttributeString("signature", Convert.ToBase64String(Ref.Signature));
                        w.WriteAttributeString("collection", Ref.Collection);
                        w.WriteAttributeString("created", XML.Encode(Ref.Created));
                        w.WriteAttributeString("creator", Ref.Creator);
 
                        if (Ref.Expires != DateTime.MaxValue)
                            w.WriteAttributeString("expires", XML.Encode(Ref.Expires));
 
                        if (Ref.Updated != DateTime.MinValue)
                            w.WriteAttributeString("updated", XML.Encode(Ref.Updated));
 
                        if (!(Ref.Link is null))
                            w.WriteAttributeString("link", Convert.ToBase64String(Ref.Link));
 
                        using (BlockEnumerator TempBlockEnumerator = new BlockEnumerator(Ref, this.provider))
                        {
                            using ObjectEnumerator<GenericObject> e = await ObjectEnumerator<GenericObject>.Create(TempBlockEnumerator, this.provider);
                            
                            while (await e.MoveNextAsync())
                            {
                                switch (e.CurrentEntry.Type)
                                {
                                    case EntryType.New:
                                        w.WriteStartElement("Add");
                                        break;
 
                                    case EntryType.Update:
                                        w.WriteStartElement("Update");
                                        break;
 
                                    case EntryType.Delete:
                                        w.WriteStartElement("Delete");
                                        break;
 
                                    case EntryType.Clear:
                                        w.WriteStartElement("Clear");
                                        w.WriteAttributeString("ts", XML.Encode(e.CurrentEntry.Timestamp));
                                        w.WriteEndElement();
                                        continue;
 
                                    default:
                                        continue;
                                }
 
                                GenericObject Obj = e.Current;
 
                                w.WriteAttributeString("ts", XML.Encode(e.CurrentEntry.Timestamp));
                                w.WriteAttributeString("type", Obj.TypeName);
                                w.WriteAttributeString("id", Obj.ObjectId.ToString());
 
                                foreach (KeyValuePair<string, object> P in Obj)
                                    this.WriteProperty(w, P.Key, P.Value);
 
                                w.WriteEndElement();
                            }
                        }
 
                        w.WriteEndElement();
                        w.WriteEndDocument();
                        w.Flush();
 
                        Response.StatusCode = 200;
                        Response.StatusMessage = "OK";
                        Response.ContentType = Alternative;
                        await Response.Write(Xml.ToString());
                        break;
 
                    case JsonCodec.DefaultContentType:
                    case "text/x-json":
                        LinkedList<KeyValuePair<string, object>> Result = new LinkedList<KeyValuePair<string, object>>();
 
                        Result.AddLast(new KeyValuePair<string, object>("digest", Convert.ToBase64String(Ref.Digest)));
                        Result.AddLast(new KeyValuePair<string, object>("status", Ref.Status.ToString()));
                        Result.AddLast(new KeyValuePair<string, object>("signature", Convert.ToBase64String(Ref.Signature)));
                        Result.AddLast(new KeyValuePair<string, object>("collection", Ref.Collection));
                        Result.AddLast(new KeyValuePair<string, object>("created", XML.Encode(Ref.Created)));
                        Result.AddLast(new KeyValuePair<string, object>("creator", Ref.Creator));
 
                        if (Ref.Expires != DateTime.MaxValue)
                            Result.AddLast(new KeyValuePair<string, object>("expires", XML.Encode(Ref.Expires)));
 
                        if (Ref.Updated != DateTime.MinValue)
                            Result.AddLast(new KeyValuePair<string, object>("updated", XML.Encode(Ref.Updated)));
 
                        if (!(Ref.Link is null))
                            Result.AddLast(new KeyValuePair<string, object>("link", Convert.ToBase64String(Ref.Link)));
 
                        LinkedList<object> Entries = new LinkedList<object>();
                        Result.AddLast(new KeyValuePair<string, object>("entries", Entries));
 
                        using (BlockEnumerator TempBlockEnumerator = new BlockEnumerator(Ref, this.provider))
                        {
                            using ObjectEnumerator<GenericObject> e = await ObjectEnumerator<GenericObject>.Create(TempBlockEnumerator, this.provider);
                            
                            while (await e.MoveNextAsync())
                            {
                                LinkedList<KeyValuePair<string, object>> P1 = new LinkedList<KeyValuePair<string, object>>();
 
                                P1.AddLast(new KeyValuePair<string, object>("type", e.CurrentEntry.Type.ToString()));
                                P1.AddLast(new KeyValuePair<string, object>("ts", XML.Encode(e.CurrentEntry.Timestamp)));
 
                                switch (e.CurrentEntry.Type)
                                {
                                    case EntryType.New:
                                    case EntryType.Update:
                                    case EntryType.Delete:
                                        LinkedList<KeyValuePair<string, object>> P2 = new LinkedList<KeyValuePair<string, object>>();
                                        GenericObject Obj = e.Current;
 
                                        P1.AddLast(new KeyValuePair<string, object>("obj", P2));
 
                                        P2.AddLast(new KeyValuePair<string, object>("type", Obj.TypeName));
                                        P2.AddLast(new KeyValuePair<string, object>("id", Obj.ObjectId.ToString()));
 
                                        foreach (KeyValuePair<string, object> P in Obj)
                                            P2.AddLast(new KeyValuePair<string, object>(P.Key, P.Value));
 
                                        break;
                                }
 
                                Entries.AddLast(P1);
                            }
                        }
 
                        Response.StatusCode = 200;
                        Response.StatusMessage = "OK";
                        Response.ContentType = Alternative;
                        await Response.Write(JSON.Encode(Result, true));
                        break;
 
                    default:
                        await Response.SendResponse(new NotAcceptableException("Desired format not acceptable. Use the Accept header field to select either text/xml, application/json or application/octet-stream."));
                        return;
                }
 
                await Response.SendResponse();
            }
            catch (Exception ex)
            {
                await Response.SendResponse(ex);
            }
        }
 
        private void WriteProperty(XmlWriter w, string Name, object Value)
        {
            if (Value is null)
            {
                w.WriteStartElement("Null");
                if (!(Name is null))
                    w.WriteAttributeString("n", string.Empty, Name);
                w.WriteEndElement();
            }
            else if (Value is Enum)
            {
                w.WriteStartElement("En");
                if (!(Name is null))
                    w.WriteAttributeString("n", string.Empty, Name);
                w.WriteAttributeString("v", string.Empty, Value.ToString());
                w.WriteEndElement();
            }
            else
            {
                switch (Type.GetTypeCode(Value.GetType()))
                {
                    case TypeCode.Boolean:
                        w.WriteStartElement("Bl");
                        if (!(Name is null))
                            w.WriteAttributeString("n", string.Empty, Name);
                        w.WriteAttributeString("v", string.Empty, CommonTypes.Encode((bool)Value));
                        w.WriteEndElement();
                        break;
 
                    case TypeCode.Byte:
                        w.WriteStartElement("B");
                        if (!(Name is null))
                            w.WriteAttributeString("n", string.Empty, Name);
                        w.WriteAttributeString("v", string.Empty, Value.ToString());
                        w.WriteEndElement();
                        break;
 
                    case TypeCode.Char:
                        w.WriteStartElement("Ch");
                        if (!(Name is null))
                            w.WriteAttributeString("n", string.Empty, Name);
                        w.WriteAttributeString("v", string.Empty, Value.ToString());
                        w.WriteEndElement();
                        break;
 
                    case TypeCode.DateTime:
                        w.WriteStartElement("DT");
                        if (!(Name is null))
                            w.WriteAttributeString("n", string.Empty, Name);
                        w.WriteAttributeString("v", string.Empty, XML.Encode((DateTime)Value));
                        w.WriteEndElement();
                        break;
 
                    case TypeCode.Decimal:
                        w.WriteStartElement("Dc");
                        if (!(Name is null))
                            w.WriteAttributeString("n", string.Empty, Name);
                        w.WriteAttributeString("v", string.Empty, CommonTypes.Encode((decimal)Value));
                        w.WriteEndElement();
                        break;
 
                    case TypeCode.Double:
                        w.WriteStartElement("Db");
                        if (!(Name is null))
                            w.WriteAttributeString("n", string.Empty, Name);
                        w.WriteAttributeString("v", string.Empty, CommonTypes.Encode((double)Value));
                        w.WriteEndElement();
                        break;
 
                    case TypeCode.Int16:
                        w.WriteStartElement("I2");
                        if (!(Name is null))
                            w.WriteAttributeString("n", string.Empty, Name);
                        w.WriteAttributeString("v", string.Empty, Value.ToString());
                        w.WriteEndElement();
                        break;
 
                    case TypeCode.Int32:
                        w.WriteStartElement("I4");
                        if (!(Name is null))
                            w.WriteAttributeString("n", string.Empty, Name);
                        w.WriteAttributeString("v", string.Empty, Value.ToString());
                        w.WriteEndElement();
                        break;
 
                    case TypeCode.Int64:
                        w.WriteStartElement("I8");
                        if (!(Name is null))
                            w.WriteAttributeString("n", string.Empty, Name);
                        w.WriteAttributeString("v", string.Empty, Value.ToString());
                        w.WriteEndElement();
                        break;
 
                    case TypeCode.SByte:
                        w.WriteStartElement("I1");
                        if (!(Name is null))
                            w.WriteAttributeString("n", string.Empty, Name);
                        w.WriteAttributeString("v", string.Empty, Value.ToString());
                        w.WriteEndElement();
                        break;
 
                    case TypeCode.Single:
                        w.WriteStartElement("Fl");
                        if (!(Name is null))
                            w.WriteAttributeString("n", string.Empty, Name);
                        w.WriteAttributeString("v", string.Empty, CommonTypes.Encode((float)Value));
                        w.WriteEndElement();
                        break;
 
                    case TypeCode.String:
                        string s = Value.ToString();
                        try
                        {
                            XmlConvert.VerifyXmlChars(s);
                            w.WriteStartElement("S");
                            if (!(Name is null))
                                w.WriteAttributeString("n", string.Empty, Name);
                            w.WriteAttributeString("v", string.Empty, s);
                            w.WriteEndElement();
                        }
                        catch (XmlException)
                        {
                            byte[] Bin = Encoding.UTF8.GetBytes(s);
                            s = Convert.ToBase64String(Bin);
                            w.WriteStartElement("S64");
                            if (!(Name is null))
                                w.WriteAttributeString("n", string.Empty, Name);
                            w.WriteAttributeString("v", string.Empty, s);
                            w.WriteEndElement();
                        }
                        break;
 
                    case TypeCode.UInt16:
                        w.WriteStartElement("U2");
                        if (!(Name is null))
                            w.WriteAttributeString("n", string.Empty, Name);
                        w.WriteAttributeString("v", string.Empty, Value.ToString());
                        w.WriteEndElement();
                        break;
 
                    case TypeCode.UInt32:
                        w.WriteStartElement("U4");
                        if (!(Name is null))
                            w.WriteAttributeString("n", string.Empty, Name);
                        w.WriteAttributeString("v", string.Empty, Value.ToString());
                        w.WriteEndElement();
                        break;
 
                    case TypeCode.UInt64:
                        w.WriteStartElement("U8");
                        if (!(Name is null))
                            w.WriteAttributeString("n", string.Empty, Name);
                        w.WriteAttributeString("v", string.Empty, Value.ToString());
                        w.WriteEndElement();
                        break;
 
                    case TypeCode.DBNull:
                    case TypeCode.Empty:
                        w.WriteStartElement("Null");
                        if (!(Name is null))
                            w.WriteAttributeString("n", string.Empty, Name);
                        w.WriteEndElement();
                        break;
 
                    case TypeCode.Object:
                        if (Value is TimeSpan)
                        {
                            w.WriteStartElement("TS");
                            if (!(Name is null))
                                w.WriteAttributeString("n", string.Empty, Name);
                            w.WriteAttributeString("v", string.Empty, Value.ToString());
                            w.WriteEndElement();
                        }
                        else if (Value is DateTimeOffset DTO)
                        {
                            w.WriteStartElement("DTO");
                            if (!(Name is null))
                                w.WriteAttributeString("n", string.Empty, Name);
                            w.WriteAttributeString("v", string.Empty, XML.Encode(DTO));
                            w.WriteEndElement();
                        }
                        else if (Value is CaseInsensitiveString Cis)
                        {
                            s = Cis.Value;
                            try
                            {
                                XmlConvert.VerifyXmlChars(s);
                                w.WriteStartElement("CIS");
                                if (!(Name is null))
                                    w.WriteAttributeString("n", string.Empty, Name);
                                w.WriteAttributeString("v", string.Empty, s);
                                w.WriteEndElement();
                            }
                            catch (XmlException)
                            {
                                byte[] Bin = Encoding.UTF8.GetBytes(s);
                                s = Convert.ToBase64String(Bin);
                                w.WriteStartElement("CIS64");
                                if (!(Name is null))
                                    w.WriteAttributeString("n", string.Empty, Name);
                                w.WriteAttributeString("v", string.Empty, s);
                                w.WriteEndElement();
                            }
                        }
                        else if (Value is byte[] Bin)
                        {
                            w.WriteStartElement("Bin");
                            if (!(Name is null))
                                w.WriteAttributeString("n", string.Empty, Name);
 
                            byte[] Buf = null;
                            int c = Bin.Length;
                            int i = 0;
                            int d;
                            int j;
 
                            while (i < c)
                            {
                                d = c - i;
                                if (d > 49152)
                                    j = 49152;
                                else
                                    j = d;
 
                                if (Buf is null)
                                {
                                    if (i == 0 && j == c)
                                        Buf = Bin;
                                    else
                                        Buf = new byte[j];
                                }
 
                                if (Buf != Bin)
                                    Buffer.BlockCopy(Bin, i, Buf, 0, j);
 
                                w.WriteElementString("Chunk", Convert.ToBase64String(Buf, 0, j, Base64FormattingOptions.None));
                                i += j;
                            }
 
                            w.WriteEndElement();
                        }
                        else if (Value is Guid)
                        {
                            w.WriteStartElement("ID");
                            if (!(Name is null))
                                w.WriteAttributeString("n", string.Empty, Name);
                            w.WriteAttributeString("v", string.Empty, Value.ToString());
                            w.WriteEndElement();
                        }
                        else if (Value is Array A)
                        {
                            w.WriteStartElement("Array");
                            if (!(Name is null))
                                w.WriteAttributeString("n", string.Empty, Name);
                            w.WriteAttributeString("elementType", string.Empty, Value.GetType().GetElementType().FullName);
 
                            foreach (object Obj in A)
                                this.WriteProperty(w, null, Obj);
 
                            w.WriteEndElement();
                        }
                        else if (Value is GenericObject Obj)
                        {
                            w.WriteStartElement("Obj");
                            if (!(Name is null))
                                w.WriteAttributeString("n", string.Empty, Name);
                            w.WriteAttributeString("type", string.Empty, Obj.TypeName);
 
                            foreach (KeyValuePair<string, object> P in Obj)
                                this.WriteProperty(w, P.Key, P.Value);
 
                            w.WriteEndElement();
                        }
                        else
                            throw new Exception("Unhandled property value type: " + Value.GetType().FullName);
                        break;
 
                    default:
                        throw new Exception("Unhandled property value type: " + Value.GetType().FullName);
                }
            }
        }
 
    }
}