MultiUserChatComponent.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.Content.Markdown;
using Waher.Content.Xml;
using Waher.Events;
using Waher.IoTGateway;
using Waher.Networking.XMPP.Server;
using Waher.Persistence;
using Waher.Persistence.Filters;
using Waher.Runtime.Cache;
using Waher.Service.IoTBroker.MultiUserChat.Affiliations;
using Waher.Service.IoTBroker.MultiUserChat.Roles;
using Waher.Service.IoTBroker.Legal.Identity;
 
namespace Waher.Service.IoTBroker.MultiUserChat
{
    public class MultiUserChatComponent : Component
    {
        public const string NamespaceMuc = "http://jabber.org/protocol/muc";
 
        public const string NamespaceMucUser = "http://jabber.org/protocol/muc#user";
 
        public const string NamespaceMucAdmin = "http://jabber.org/protocol/muc#admin";
 
        public const string NamespaceMucOwner = "http://jabber.org/protocol/muc#owner";
 
        public const string FormTypeRegister = "http://jabber.org/protocol/muc#register";
 
        public const string FormTypeRequest = "http://jabber.org/protocol/muc#request";
 
        public const string FormTypeRoomConfig = "http://jabber.org/protocol/muc#roomconfig";
 
        private readonly Cache<CaseInsensitiveString, MucRoom> rooms = new Cache<CaseInsensitiveString, MucRoom>(int.MaxValue, TimeSpan.MaxValue, TimeSpan.FromDays(1));
 
        public MultiUserChatComponent(XmppServer Server, CaseInsensitiveString Subdomain, string Name)
            : base(Server, Subdomain, Name)
        {
            this.RegisterPresenceHandler("x", NamespaceMuc, this.EnterRoomHandler, true);
            this.RegisterMessageHandler("x", NamespaceMucUser, this.UserCommandHandler, true);
            this.RegisterMessageHandler("x", XmppServer.DataFormsNamespace, this.FormSubmissionHandler, true);
            this.RegisterIqGetHandler("query", XmppServer.RegisterNamespace, this.RegisterUserGetFormHandler, true);
            this.RegisterIqSetHandler("query", XmppServer.RegisterNamespace, this.RegisterUserSubmitFormHandler, false);
            this.RegisterIqGetHandler("query", NamespaceMucAdmin, this.AdminQueryHandler, false);
            this.RegisterIqSetHandler("query", NamespaceMucAdmin, this.AdminCommandHandler, true);
            this.RegisterIqGetHandler("query", NamespaceMucOwner, this.OwnerQueryHandler, false);
            this.RegisterIqSetHandler("query", NamespaceMucOwner, this.OwnerCommandHandler, false);
            this.RegisterIqGetHandler("ping", XmppServer.PingNamespace, this.SelfPingHandler, true);
            this.RegisterFeature("muc_rooms");
            this.RegisterFeature("http://jabber.org/protocol/muc#self-ping-optimization");
        }
 
        public override void Dispose()
        {
            this.UnregisterPresenceHandler("x", NamespaceMuc, this.EnterRoomHandler, true);
            this.UnregisterMessageHandler("x", NamespaceMucUser, this.UserCommandHandler, true);
            this.UnregisterMessageHandler("x", XmppServer.DataFormsNamespace, this.FormSubmissionHandler, true);
            this.UnregisterIqGetHandler("query", XmppServer.RegisterNamespace, this.RegisterUserGetFormHandler, true);
            this.UnregisterIqSetHandler("query", XmppServer.RegisterNamespace, this.RegisterUserSubmitFormHandler, false);
            this.UnregisterIqGetHandler("query", NamespaceMucAdmin, this.AdminQueryHandler, false);
            this.UnregisterIqSetHandler("query", NamespaceMucAdmin, this.AdminCommandHandler, true);
            this.UnregisterIqGetHandler("query", NamespaceMucOwner, this.OwnerQueryHandler, false);
            this.UnregisterIqSetHandler("query", NamespaceMucOwner, this.OwnerCommandHandler, false);
            this.UnregisterIqGetHandler("ping", XmppServer.PingNamespace, this.SelfPingHandler, true);
            this.UnregisterFeature("muc_rooms");
            this.UnregisterFeature("http://jabber.org/protocol/muc#self-ping-optimization");
 
            this.rooms.Dispose();
 
            base.Dispose();
        }
 
        public override bool SupportsAccounts => true;
 
        private async Task EnterRoomHandler(object Sender, PresenceEventArgs e)
        {
            if (e.From.IsBareJID)
            {
                await e.PresenceErrorJidMalformed(e.To, "From JID must be a full JID.", "en");
                return;
            }
 
            if (!e.To.HasAccount)
            {
                await e.PresenceErrorJidMalformed(e.To, "Missing room name.", "en");
                return;
            }
 
            if (e.To.IsBareJID)
            {
                await e.PresenceErrorJidMalformed(e.To, "Missing room nick name.", "en");
                return;
            }
 
            CaseInsensitiveString RoomId = e.To.Account;
            CaseInsensitiveString NickName = e.To.Resource;
            MucRoom Room = await this.GetRoom(RoomId, e.To.Domain);
            StringBuilder sb;
            bool RoomCreated = false;
 
            if (Room is null)
            {
                if (!this.Server.IsServerDomain(e.From.Domain, true))
                {
                    await e.PresenceErrorNotAllowed(e.To, "Only users with accounts on the server can create rooms on the server.", "en");
                    return;
                }
 
                if (!(XmppServerModule.Legal is null))
                {
                    LegalIdentity Identity = await XmppServerModule.Legal.GetCurrentApprovedLegalIdentityAsync(e.From.Account);
                    if (Identity is null)
                    {
                        await e.PresenceErrorNotAllowed(e.To, "Only users with approved legal identities on the server can create rooms on the server.", "en");
                        return;
                    }
                }
 
                Room = new MucRoom()
                {
                    Room = RoomId,
                    Domain = e.To.Domain,
                    Creator = e.From.BareJid,
                    Admins = new CaseInsensitiveString[] { e.From.BareJid },
                    Owners = new CaseInsensitiveString[] { e.From.BareJid },
                    Persistent = false,
                    Locked = true
                };
 
                this.rooms[RoomId] = Room;
                RoomCreated = true;
 
                Log.Informational("Room created", RoomId, e.From.BareJid,
                    new KeyValuePair<string, object>("Room", RoomId),
                    new KeyValuePair<string, object>("Domain", e.To.Domain),
                    new KeyValuePair<string, object>("Creator", e.From.BareJid));
            }
 
            if (Room.PasswordProtected)
            {
                string Password = null;
 
                foreach (XmlNode N in e.Content.ChildNodes)
                {
                    if (N is XmlElement E && E.LocalName == "password" && E.NamespaceURI == NamespaceMuc)
                    {
                        Password = E.InnerText;
                        break;
                    }
                }
 
                DateTime? Next = await (Gateway.LoginAuditor?.GetEarliestLoginOpportunity(e.From.BareJid.LowerCase, "MUC") ?? Task.FromResult<DateTime?>(null));
 
                if (Next.HasValue)
                {
                    DateTime TP = Next.Value;
                    DateTime Today = DateTime.Today;
 
                    sb = new StringBuilder();
 
                    if (Next.Value == DateTime.MaxValue)
                    {
                        sb.Append("This endpoint (");
                        sb.Append(e.From.BareJid.LowerCase);
                        sb.Append(") has been blocked from the system.");
 
                        await e.PresenceErrorForbidden(e.To, sb.ToString(), "en");
                        return;
                    }
                    else
                    {
                        sb.Append("Too many failed login attempts in a row registered. Try again after ");
                        sb.Append(TP.ToLongTimeString());
 
                        if (TP.Date != Today)
                        {
                            if (TP.Date == Today.AddDays(1))
                                sb.Append(" tomorrow");
                            else
                            {
                                sb.Append(", ");
                                sb.Append(TP.ToShortDateString());
                            }
                        }
 
                        sb.Append(". Remote Endpoint: ");
                        sb.Append(e.From.BareJid.LowerCase);
 
                        await e.PresenceErrorNotAuthorized(e.To, sb.ToString(), "en");
                        return;
                    }
                }
 
                if (Password is null || Room.Password != Password)
                {
                    await e.PresenceErrorNotAuthorized(e.To, "Room ID or password incorrect.", "en");
                    return;
                }
            }
 
            if (!Room.TryGetOccupantFromNick(NickName, out MucOccupant Occupant))
            {
                Occupant = await Database.FindFirstDeleteRest<MucOccupant>(new FilterAnd(
                    new FilterFieldEqualTo("Domain", e.To.Domain),
                    new FilterFieldEqualTo("Room", RoomId),
                    new FilterFieldEqualTo("NickName", NickName)));
 
                if (!(Occupant is null) && !Room.Add(Occupant))
                {
                    await e.PresenceErrorServiceUnavailable(e.To, "Room is full.", "en");
                    return;
                }
            }
 
            if (!(Occupant is null))
            {
                if (Occupant.BareJid != e.From.BareJid)
                {
                    await e.PresenceErrorConflict(e.To, "Nick-name conflict.", "en");
                    return;
                }
 
                if (Occupant.Role is null)
                {
                    await e.PresenceErrorRegistrationRequired(e.To, "Registration has not been granted yet.", "en");
                    return;
                }
            }
            else
            {
                Affiliation Affiliation = Room.GetDefaultAffiliation(e.From.BareJid);
                Role Role = Affiliation.GetDefaultRole(Room);
 
                if (Role is null)
                {
                    if (Room.Locked)
                        await e.PresenceErrorItemNotFound(e.To, "Room is locked.", "en");
                    else if (Room.MembersOnly)
                        await e.PresenceErrorRegistrationRequired(e.To, "Entry to room requires membership registration.", "en");
                    else
                        await e.PresenceErrorForbidden(e.To, "Entry to room denied.", "en");
 
                    return;
                }
 
                Occupant = new MucOccupant()
                {
                    Room = RoomId,
                    Domain = e.To.Domain,
                    NickName = NickName,
                    BareJid = e.From.BareJid,
                    FullJids = new XmppAddress[] { e.From },
                    Affiliation = Affiliation,
                    Role = Role,
                    Persistent = Room.Persistent,
                    Archive = Room.Archive
                };
 
                if (!Room.Add(Occupant))
                {
                    await e.PresenceErrorServiceUnavailable(e.To, "Room is full.", "en");
                    return;
                }
 
                if (Occupant.Persistent)
                    await Database.InsertLazy(Occupant);
            }
 
            await this.OccupantEntered(Room, Occupant, e.From, RoomCreated, e.Id, e.Content);
        }
 
        private async Task OccupantEntered(MucRoom Room, MucOccupant Occupant, XmppAddress From,
            bool RoomCreated, string Id, XmlElement PresenceContent)
        {
            Room.RegisterFullJid(Occupant, From);
 
            bool CanBroadcastOccupant = Room.CanBroadcastPresence(Occupant);
            string OccupantXmlNoJid = Occupant.GetUserXml(null, null);
            string OccupantXmlWithJid = Occupant.GetUserXml(From.Address, null);
            XmppAddress OccupantJid = new XmppAddress(Occupant.OccupantJid);
            bool CanGetMembership = (Occupant.Role?.ReceiveOccupantPresence ?? false) && Room.CanGetMembership(Occupant);
            bool CanViewJid = Room.CanDiscoverRealJids(Occupant);
 
            foreach (MucOccupant Occupant2 in Room.GetOccupants())
            {
                if (AreEqual(Occupant2.FullJids, Occupant.FullJids))
                    continue;
 
                if (CanGetMembership && Room.CanBroadcastPresence(Occupant2))
                {
                    if (CanViewJid)
                    {
                        if (!(Occupant2.FullJids is null))
                        {
                            foreach (XmppAddress FullJid in Occupant2.FullJids)
                            {
                                await this.Server.Presence(string.Empty, Guid.NewGuid().ToString(), From, new XmppAddress(Occupant2.OccupantJid),
                                    string.Empty, Occupant2.GetUserXml(FullJid.Address, null), this);
                            }
                        }
                    }
                    else
                    {
                        await this.Server.Presence(string.Empty, Guid.NewGuid().ToString(), From, new XmppAddress(Occupant2.OccupantJid),
                            string.Empty, Occupant2.GetUserXml(null, null), this);
                    }
                }
 
                if (CanBroadcastOccupant && (Occupant2.Role?.ReceiveOccupantPresence ?? false) && Room.CanGetMembership(Occupant2))
                {
                    if (!(Occupant2.FullJids is null))
                    {
                        foreach (XmppAddress FullJid in Occupant2.FullJids)
                        {
                            await this.Server.Presence(string.Empty, Guid.NewGuid().ToString(), FullJid, OccupantJid, string.Empty,
                                Room.CanDiscoverRealJids(Occupant2) ? OccupantXmlWithJid : OccupantXmlNoJid, this);
                        }
                    }
                }
            }
 
            List<int> StatusCodes = new List<int>();
 
            if (Room.DiscoverRealJids == DiscoverReadJids.Anyone)
                StatusCodes.Add(100);
 
            StatusCodes.Add(110);
 
            if (Room.Logging)
                StatusCodes.Add(170);
 
            if (RoomCreated)
                StatusCodes.Add(201);
 
            await this.Server.Presence(string.Empty, string.IsNullOrEmpty(Id) ? Guid.NewGuid().ToString() : Id, From, OccupantJid,
                string.Empty, Occupant.GetUserXml(CanViewJid ? From.Address : null, null, StatusCodes.ToArray()), this);
 
            string RoomAddr = XML.Encode(Room.Room + "@" + Room.Domain);
            bool IncludeJid = Room.CanDiscoverRealJids(Occupant);
 
            StringBuilder sb = new StringBuilder();
 
            if (Room.Persistent && (Occupant.Role?.ReceiveMessages ?? false) && Room.MaxHistoryFetch > 0)
            {
                List<FilterField> Fields = new List<FilterField>()
                {
                    new FilterFieldEqualTo("Domain", Room.Domain),
                    new FilterFieldEqualTo("Room", Room.Room)
                };
                int MaxStanzas = Room.MaxHistoryFetch;
                int MaxSize = int.MaxValue;
 
                if (!(PresenceContent is null))
                {
                    foreach (XmlNode N in PresenceContent.ChildNodes)
                    {
                        if (N is XmlElement E && E.LocalName == "history" && E.NamespaceURI == NamespaceMuc)
                        {
                            foreach (XmlAttribute Attr in E.Attributes)
                            {
                                switch (Attr.Name)
                                {
                                    case "maxchars":
                                        if (int.TryParse(Attr.Value, out int i))
                                            MaxSize = i;
                                        break;
 
                                    case "maxstanzas":
                                        if (int.TryParse(Attr.Value, out i))
                                            MaxStanzas = i;
                                        break;
 
                                    case "seconds":
                                        if (int.TryParse(Attr.Value, out i))
                                            Fields.Add(new FilterFieldGreaterOrEqualTo("Timestamp", DateTime.Now.AddSeconds(-i)));
                                        break;
 
                                    case "since":
                                        if (XML.TryParse(Attr.Value, out DateTime TP))
                                            Fields.Add(new FilterFieldGreaterOrEqualTo("Timestamp", TP));
                                        break;
                                }
                            }
                        }
                    }
                }
 
                if (MaxSize > 0 && MaxStanzas > 0)
                {
                    IEnumerable<MucMessage> History = await Database.Find<MucMessage>(0, MaxStanzas, new FilterAnd(Fields.ToArray()), "-Timestamp");
                    List<MucMessage> Messages = new List<MucMessage>();
                    string Xml;
                    int Len;
 
                    foreach (MucMessage Message in History)
                        Messages.Add(Message);
 
                    Messages.Reverse();
 
                    foreach (MucMessage Message in Messages)
                    {
                        sb.Append(Message.ContentXml);
                        sb.Append("<delay xmlns='");
                        sb.Append(XmppServer.DelayedDeliveryNamespace);
                        sb.Append("' from='");
                        sb.Append(RoomAddr);
                        sb.Append("' stamp='");
                        sb.Append(XML.Encode(Message.Timestamp));
                        sb.Append("'/>");
 
                        if (IncludeJid && !CaseInsensitiveString.IsNullOrEmpty(Message.FullJid))
                        {
                            sb.Append("<addresses xmlns='");
                            sb.Append(XmppServer.ExtendedAddressingNamespace);
                            sb.Append("'><address type='ofrom' jid='");
                            sb.Append(XML.Encode(Message.FullJid.Value));
                            sb.Append("'/></addresses>");
                        }
 
                        Xml = sb.ToString();
                        OccupantJid = new XmppAddress(Message.OccupantJid);
                        sb.Clear();
 
                        if (MaxSize < int.MaxValue)
                        {
                            Len = Xml.Length;
                            Len += 19;  // <message...>...</message>
 
                            if (!string.IsNullOrEmpty(Message.MessageId))
                            {
                                Len += 6;   // _id='...'
                                Len += XML.Encode(Message.MessageId).Length;
                            }
 
                            Len += 17;  // _type='groupchat'
                            Len += 6;   // _to='...'
                            Len += XML.Encode(From.Address).Length;
                            Len += 8;   // _from='...'
                            Len += XML.Encode(OccupantJid.Address).Length;
 
                            if (!string.IsNullOrEmpty(Message.Language))
                            {
                                Len += 12;  // _xml:lang='...'
                                Len += XML.Encode(Message.Language).Length;
                            }
 
                            Len += Xml.Length;
 
                            if (Len > MaxSize)
                                break;
 
                            MaxSize -= Len;
                        }
 
                        await this.Server.Message("groupchat", Message.MessageId, From, OccupantJid, Message.Language, Xml, this);
                    }
                }
            }
 
            if (Room.SubjectTimestamp > DateTime.MinValue)
            {
                sb.Append("<subject>");
                sb.Append(XML.Encode(Room.Subject));
                sb.Append("</subject>");
                sb.Append("<delay xmlns='");
                sb.Append(XmppServer.DelayedDeliveryNamespace);
                sb.Append("' from='");
                sb.Append(RoomAddr);
                sb.Append("' stamp='");
                sb.Append(XML.Encode(Room.SubjectTimestamp));
                sb.Append("'/>");
 
                await this.Server.Message("groupchat", Guid.NewGuid().ToString(), From, new XmppAddress(Room.SubjectJid), string.Empty, sb.ToString(), this);
            }
        }
 
        protected override async Task PresenceNoHandlerReceived(PresenceEventArgs e)
        {
            MucRoom Room = await this.GetRoom(e.To.Account, e.To.Domain);
            if (Room is null || !Room.TryGetOccupantFromFullJid(e.From.Address, out MucOccupant Occupant))
            {
                StringBuilder Xml = new StringBuilder();
 
                Xml.Append("<x xmlns='");
                Xml.Append(MultiUserChatComponent.NamespaceMucUser);
                Xml.Append("'><item affiliation='none' role='none'><reason>You are not in the room.</reason></item>");
                Xml.Append("<status code='110'/>");
                Xml.Append("<status code='307'/>");
                Xml.Append("<status code='333'/>");
                Xml.Append("</x>");
 
                await this.Server.Presence(string.Empty, string.IsNullOrEmpty(e.Id) ? Guid.NewGuid().ToString() : e.Id,
                    e.From, e.To, string.Empty, Xml.ToString(), this);
 
                return;
            }
 
            if (e.Type == "error")
            {
                Room.Remove(Occupant);
 
                StringBuilder Xml = new StringBuilder();
 
                Xml.Append("<x xmlns='");
                Xml.Append(MultiUserChatComponent.NamespaceMucUser);
                Xml.Append("'><item affiliation='none' role='none'/>");
                Xml.Append("<status code='333'/>");
                Xml.Append("</x>");
 
                await this.PresenceXmlToAll(e.To, Room.GetOccupants(), Xml.ToString());
 
                return;
            }
 
            if (e.To.Resource == Occupant.NickName)
            {
                XmppAddress OccupantJid = new XmppAddress(Occupant.OccupantJid);
                bool Broadcast = Room.CanBroadcastPresence(Occupant);
 
                if (e.Type == "unavailable")
                {
                    if (Room.UnregisterFullJid(Occupant, e.From))
                    {
                        Room.Remove(Occupant);
                        Occupant.Role = new Roles.None();
                    }
                }
 
                if (Broadcast)
                {
                    string SuffixWithJid = null;
                    string SuffixWithoutJid = null;
                    string Suffix;
 
                    foreach (MucOccupant Occupant2 in Room.GetOccupants())
                    {
                        if (!(Occupant2.Role?.ReceiveOccupantPresence ?? false))
                            continue;
 
                        if (Room.CanDiscoverRealJids(Occupant2))
                        {
                            if (SuffixWithJid is null)
                                SuffixWithJid = Occupant.GetUserXml(e.From.Address, null);
 
                            Suffix = SuffixWithJid;
                        }
                        else
                        {
                            if (SuffixWithoutJid is null)
                                SuffixWithoutJid = Occupant.GetUserXml(null, null);
 
                            Suffix = SuffixWithoutJid;
                        }
 
                        if (!(Occupant2.FullJids is null))
                        {
                            foreach (XmppAddress FullJid in Occupant2.FullJids)
                                await this.Server.Presence(e.Type, e.Id, FullJid, OccupantJid, e.Language, InnerXmlNoJabberNamespace(e.Stanza?.StanzaElement) + Suffix, this);
                        }
                    }
                }
 
                await this.Server.Presence(e.Type, e.Id, e.From, OccupantJid, e.Language,
                    InnerXmlNoJabberNamespace(e.Stanza?.StanzaElement) + Occupant.GetUserXml(null, null, 110), this);
            }
            else if (string.IsNullOrEmpty(e.Type))
            {
                MucOccupant Occupant2 = await this.GetOccupantByNickName(Room, e.To.Resource);
                if (!(Occupant2 is null) && !Occupant2.ContainsFullJid(e.From))
                {
                    await e.PresenceErrorConflict(e.To, "Nick-name conflict.", "en");
                    return;
                }
 
                if (!(Occupant.Role?.ChangeRoomNickname ?? false))
                {
                    await e.PresenceErrorNotAcceptable(e.To, "Nick-name cannot be changed.", "en");
                    return;
                }
 
                XmppAddress OldAddr = new XmppAddress(Occupant.OccupantJid);
 
                Room.UnregisterFullJid(Occupant, e.From);
 
                if (Occupant.HasFullJids)
                {
                    Occupant = new MucOccupant()
                    {
                        Room = e.To.Account,
                        Domain = e.To.Domain,
                        NickName = e.To.Resource,
                        BareJid = e.From.BareJid,
                        FullJids = new XmppAddress[] { e.From },
                        Affiliation = Room.GetDefaultAffiliation(e.From.BareJid),
                        Persistent = Room.Persistent,
                        Archive = Room.Archive
                    };
 
                    Occupant.Role = Occupant.Affiliation.GetDefaultRole(Room);
 
                    if (!(Occupant is null) && !Room.Add(Occupant))
                    {
                        await e.PresenceErrorServiceUnavailable(e.To, "Room is full.", "en");
                        return;
                    }
 
                    if (Occupant.Persistent)
                        await Database.InsertLazy(Occupant);
                }
                else
                {
                    Occupant.NickName = e.To.Resource;
 
                    if (Occupant.Persistent)
                        await Database.UpdateLazy(Occupant);
                }
 
                Room.RegisterFullJid(Occupant, e.From);
 
                XmppAddress NewAddr = new XmppAddress(Occupant.OccupantJid);
                string OldIncludingJid = null;
                string OldExcludingJid = null;
                string NewIncludingJid = null;
                string NewExcludingJid = null;
                string OldXml;
                string NewXml;
 
                foreach (MucOccupant Occupant3 in Room.GetOccupants())
                {
                    if (Room.CanDiscoverRealJids(Occupant3))
                    {
                        if (OldIncludingJid is null)
                            OldIncludingJid = Occupant.GetUserXml(e.From.Address, OldAddr.Resource, 303);
 
                        OldXml = OldIncludingJid;
                    }
                    else
                    {
                        if (OldExcludingJid is null)
                            OldExcludingJid = Occupant.GetUserXml(null, OldAddr.Resource, 303);
 
                        OldXml = OldExcludingJid;
                    }
 
                    if (Room.CanDiscoverRealJids(Occupant))
                    {
                        if (NewIncludingJid is null)
                            NewIncludingJid = Occupant.GetUserXml(e.From.Address, NewAddr.Resource);
 
                        NewXml = NewIncludingJid;
                    }
                    else
                    {
                        if (NewExcludingJid is null)
                            NewExcludingJid = Occupant.GetUserXml(null, NewAddr.Resource);
 
                        NewXml = NewExcludingJid;
                    }
 
                    if (!(Occupant3.FullJids is null))
                    {
                        foreach (XmppAddress FullJid in Occupant3.FullJids)
                        {
                            if (FullJid != e.From)
                            {
                                await this.Server.Presence("unavailable", Guid.NewGuid().ToString(), FullJid, OldAddr, string.Empty, OldXml, this);
                                await this.Server.Presence(e.Type, e.Id, FullJid, NewAddr, string.Empty, NewXml, this);
                            }
                        }
                    }
                }
 
                await this.Server.Presence("unavailable", Guid.NewGuid().ToString(), e.From, OldAddr, string.Empty,
                    Occupant.GetUserXml(Room.CanDiscoverRealJids(Occupant) ? e.From.Address : null, OldAddr.Resource, 303, 110), this);
 
                await this.Server.Presence(e.Type, e.Id, e.From, NewAddr, string.Empty,
                    Occupant.GetUserXml(Room.CanDiscoverRealJids(Occupant) ? e.From.Address : null, NewAddr.Resource, 110), this);
            }
            else
                await e.PresenceErrorNotAcceptable(e.To, "Invalid type or nick-name.", "en");
        }
 
        private async Task<MucRoom> GetRoom(CaseInsensitiveString RoomId, CaseInsensitiveString Domain)
        {
            if (this.rooms.TryGetValue(RoomId, out MucRoom Room))
                return Room;
 
            Room = await Database.FindFirstDeleteRest<MucRoom>(new FilterAnd(
                new FilterFieldEqualTo("Domain", Domain),
                new FilterFieldEqualTo("Room", RoomId)));
 
            if (!(Room is null))
                this.rooms[RoomId] = Room;
 
            return Room;
        }
 
        private async Task<MucOccupant> GetOccupantByBareJid(MucRoom Room, CaseInsensitiveString BareJid)
        {
            if (Room.TryGetOccupantFromBareJid(BareJid, out MucOccupant Occupant))
                return Occupant;
 
            Occupant = await Database.FindFirstDeleteRest<MucOccupant>(new FilterAnd(
                new FilterFieldEqualTo("Domain", Room.Domain),
                new FilterFieldEqualTo("Room", Room.Room),
                new FilterFieldEqualTo("BareJid", BareJid)));
 
            if (!(Occupant is null))
                Room.Add(Occupant);
 
            return Occupant;
        }
 
        private async Task<MucOccupant> GetOccupantByNickName(MucRoom Room, CaseInsensitiveString NickName)
        {
            if (Room.TryGetOccupantFromNick(NickName, out MucOccupant Occupant))
                return Occupant;
 
            Occupant = await Database.FindFirstDeleteRest<MucOccupant>(new FilterAnd(
                new FilterFieldEqualTo("Domain", Room.Domain),
                new FilterFieldEqualTo("Room", Room.Room),
                new FilterFieldEqualTo("NickName", NickName)));
 
            if (!(Occupant is null))
                Room.Add(Occupant);
 
            return Occupant;
        }
 
        protected override async Task MessageNoHandlerReceived(MessageEventArgs e)
        {
            if (!e.From.IsFullJID)
                return;
 
            MucRoom Room = await this.GetRoom(e.To.Account, e.To.Domain);
            if (Room is null)
            {
                await e.MessageErrorNotAcceptable(e.To, "Not occupant of room.", "en");
                return;
            }
 
            if (!Room.TryGetOccupantFromFullJid(e.From.Address, out MucOccupant Occupant))
            {
                await e.MessageErrorNotAcceptable(e.To, "Not occupant of room.", "en");
                return;
            }
 
            if (e.Type == "error")
            {
                Room.Remove(Occupant);
 
                StringBuilder Xml = new StringBuilder();
 
                Xml.Append("<x xmlns='");
                Xml.Append(MultiUserChatComponent.NamespaceMucUser);
                Xml.Append("'><item affiliation='none' role='none'/>");
                Xml.Append("<status code='333'/>");
                Xml.Append("</x>");
 
                await this.PresenceXmlToAll(e.To, Room.GetOccupants(), Xml.ToString());
 
                return;
            }
 
            string Subject = null;
            bool OnlySubject = true;
 
            foreach (XmlNode N in e.Message.ChildNodes)
            {
                if (N is XmlElement E)
                {
                    if (E.Name == "subject" && E.NamespaceURI == e.Message.NamespaceURI)
                        Subject = E.InnerText;
                    else
                        OnlySubject = false;
                }
            }
 
            switch (e.Type)
            {
                case "groupchat":
                    if (!e.To.IsBareJID)
                    {
                        await e.MessageErrorBadRequest(e.To, "Group chat messages must be addressed to the room JID.", "en");
                        return;
                    }
 
                    if (!(Occupant.Role?.SendMessagesToAll ?? false) || !(Occupant.Role?.PresentInRoom ?? false))
                    {
                        await e.MessageErrorForbidden(e.To, "Not allowed to send messages to occupants of room.", "en");
                        return;
                    }
 
                    if (!(Subject is null) && OnlySubject)
                    {
                        if ((Room.AllowChangeSubject && (Occupant.Role?.ModifySubject ?? false)) ||
                            Room.IsModerator(Occupant))
                        {
                            Room.Subject = Subject;
                            Room.SubjectJid = Occupant.OccupantJid;
                            Room.SubjectTimestamp = DateTime.UtcNow;
 
                            if (Room.Persistent)
                                await Database.UpdateLazy(Room);
                        }
                        else
                        {
                            await e.MessageErrorForbidden(e.To, "Not allowed to change room subject.", "en");
                            return;
                        }
                    }
 
                    if (Room.Persistent && Room.Logging && !OnlySubject)
                    {
                        await Database.InsertLazy(new MucMessage()
                        {
                            Domain = e.To.Domain,
                            Room = e.To.Account,
                            NickName = Occupant.NickName,
                            MessageId = e.Id,
                            Timestamp = DateTime.UtcNow,
                            ContentXml = InnerXmlNoJabberNamespace(e.Message),
                            Language = e.Language,
                            FullJid = e.From.Address,
                            ArchiveDays = Room.Archive ? Room.ArchiveDays : 0
                        });
                    }
 
                    XmppAddress OccupantJid = new XmppAddress(Occupant.OccupantJid);
                    string SenderXml = null;
 
                    foreach (MucOccupant Occupant2 in Room.GetOccupants())
                    {
                        if (!(Occupant2.FullJids is null))
                        {
                            bool IncludeJid = Room.CanDiscoverRealJids(Occupant2);
                            string Xml = InnerXmlNoJabberNamespace(e.Message);
 
                            if (IncludeJid)
                            {
                                if (SenderXml is null)
                                {
                                    StringBuilder sb = new StringBuilder();
 
                                    sb.Append("<addresses xmlns='");
                                    sb.Append(XmppServer.ExtendedAddressingNamespace);
                                    sb.Append("'><address type='ofrom' jid='");
                                    sb.Append(XML.Encode(e.From.Address.Value));
                                    sb.Append("'/></addresses>");
 
                                    SenderXml = sb.ToString();
                                }
 
                                Xml += SenderXml;
                            }
 
                            foreach (XmppAddress To in Occupant2.FullJids)
                                await this.Server.Message(e.Type, e.Id, To, OccupantJid, e.Language, Xml, this);
                        }
                    }
                    break;
 
                default:
                    await this.SendPrivateMessage(Room, Occupant, e);
                    break;
            }
        }
 
        private async Task SendPrivateMessage(MucRoom Room, MucOccupant Occupant, MessageEventArgs e)
        {
            if (!e.To.IsFullJID)
            {
                await e.MessageErrorBadRequest(e.To, "Private messages must be addressed to individual room occupants.", "en");
                return;
            }
 
            if (!Room.CanSendPrivateMessage(Occupant))
            {
                await e.MessageErrorForbidden(e.To, "Not allowed to send private messages to occupants of room", "en");
                return;
            }
 
            MucOccupant Destination = await this.GetOccupantByNickName(Room, e.To.Resource);
            if (Destination is null)
            {
                await e.MessageErrorItemNotFound(e.To, "Recipient not an occupant of the room", "en");
                return;
            }
 
            if (!(Destination.FullJids is null))
            {
                XmppAddress OccupantJid = new XmppAddress(Occupant.OccupantJid);
 
                foreach (XmppAddress To in Destination.FullJids)
                    await this.Server.Message(e.Type, e.Id, To, OccupantJid, e.Language, InnerXmlNoJabberNamespace(e.Message), this);
            }
        }
 
        private async Task UserCommandHandler(object Sender, MessageEventArgs e)
        {
            if (e.From.IsBareJID)
            {
                await e.MessageErrorJidMalformed(e.To, "From JID must be a full JID.", "en");
                return;
            }
 
            if (!e.To.HasAccount)
            {
                await e.MessageErrorJidMalformed(e.To, "Missing room name.", "en");
                return;
            }
 
            CaseInsensitiveString RoomId = e.To.Account;
            MucRoom Room = await this.GetRoom(RoomId, e.To.Domain);
 
            if (Room is null)
            {
                await e.MessageErrorItemNotFound(e.To, "Room not found.", "en");
                return;
            }
 
            if (e.To.IsBareJID)
            {
                foreach (XmlNode N in e.Content.ChildNodes)
                {
                    if (!(N is XmlElement E) || E.NamespaceURI != NamespaceMucUser)
                        continue;
 
                    switch (E.LocalName)
                    {
                        case "invite":
 
                            if (!Room.TryGetOccupantFromFullJid(e.From.Address, out MucOccupant Occupant))
                            {
                                await e.MessageErrorForbidden(e.To, "Not an occupant of room.", "en");
                                return;
                            }
 
                            if (!(Occupant.Affiliation is Affiliations.Admin))
                            {
                                if (!Room.AllowInvites)
                                {
                                    await e.MessageErrorForbidden(e.To, "Room does not allow invitations.", "en");
                                    break;
                                }
 
                                if (!(Occupant.Role?.InviteOtherUsers ?? false))
                                {
                                    await e.MessageErrorForbidden(e.To, "You are not allowed to send invitations to this room.", "en");
                                    break;
                                }
                            }
 
                            if (Room.MembersOnly)
                            {
                                if (!Room.IsAdmin(Occupant))
                                {
                                    await e.MessageErrorForbidden(e.To, "Only room administrators or owners are allowed to invite new members.", "en");
                                    break;
                                }
                            }
 
                            XmppAddress To = new XmppAddress(XML.Attribute(E, "to"));
                            string Reason = null;
 
                            if (!To.HasAccount || !To.IsBareJID)
                            {
                                await e.MessageErrorBadRequest(e.To, "Bad address.", "en");
                                break;
                            }
 
                            if (Room.MembersOnly && Room.AddMember(To.BareJid) && Room.Persistent)
                                await Database.UpdateLazy(Room);
 
                            foreach (XmlNode N2 in E.ChildNodes)
                            {
                                if (N2 is XmlElement E2 && E2.LocalName == "reason" && E2.NamespaceURI == NamespaceMucUser)
                                {
                                    Reason = E2.InnerText;
                                    break;
                                }
                            }
 
                            StringBuilder Xml = new StringBuilder();
 
                            Xml.Append("<x xmlns='");
                            Xml.Append(NamespaceMucUser);
                            Xml.Append("'><invite from='");
                            Xml.Append(XML.Encode(e.From.Address.Value));
                            Xml.Append("'>");
 
                            if (!(Reason is null))
                            {
                                Xml.Append("<reason>");
                                Xml.Append(XML.Encode(Reason));
                                Xml.Append("</reason>");
                            }
 
                            Xml.Append("</invite>");
 
                            if (Room.PasswordProtected)
                            {
                                Xml.Append("<password>");
                                Xml.Append(XML.Encode(Room.Password));
                                Xml.Append("</password>");
                            }
 
                            Xml.Append("</x>");
 
                            await this.Server.Message(string.Empty, Guid.NewGuid().ToString(), To, e.To, e.Language, Xml.ToString(), this);
                            break;
 
                        case "decline":
 
                            To = new XmppAddress(XML.Attribute(E, "to"));
                            Reason = null;
 
                            if (!To.HasAccount || !To.IsBareJID)
                            {
                                await e.MessageErrorBadRequest(e.To, "Bad address.", "en");
                                break;
                            }
 
                            if (Room.MembersOnly && Room.RemoveMember(e.From.BareJid) && Room.Persistent)
                                await Database.UpdateLazy(Room);
 
                            foreach (XmlNode N2 in E.ChildNodes)
                            {
                                if (N2 is XmlElement E2 && E2.LocalName == "reason" && E2.NamespaceURI == NamespaceMucUser)
                                {
                                    Reason = E2.InnerText;
                                    break;
                                }
                            }
 
                            Xml = new StringBuilder();
 
                            Xml.Append("<x xmlns='");
                            Xml.Append(NamespaceMucUser);
                            Xml.Append("'><decline from='");
                            Xml.Append(XML.Encode(e.From.BareJid.Value));
                            Xml.Append("'>");
 
                            if (!(Reason is null))
                            {
                                Xml.Append("<reason>");
                                Xml.Append(XML.Encode(Reason));
                                Xml.Append("</reason>");
                            }
 
                            Xml.Append("</decline></x>");
 
                            await this.Server.Message(string.Empty, Guid.NewGuid().ToString(), To, e.To, e.Language, Xml.ToString(), this);
                            break;
                    }
                }
            }
            else
            {
                if (!Room.TryGetOccupantFromFullJid(e.From.Address, out MucOccupant Occupant))
                {
                    await e.MessageErrorForbidden(e.To, "Not an occupant of room.", "en");
                    return;
                }
 
                if (e.Type == "chat")
                    await this.SendPrivateMessage(Room, Occupant, e);
                else
                    await e.MessageErrorJidMalformed(e.To, "Message must be addressed to room.", "en");
            }
        }
 
        private async Task RegisterUserGetFormHandler(object Sender, IqEventArgs e)
        {
            if (!e.To.HasAccount)
            {
                await e.IqErrorJidMalformed(e.To, "Missing room name.", "en");
                return;
            }
 
            if (!e.To.IsBareJID)
            {
                await e.IqErrorJidMalformed(e.To, "Message must be addressed to room.", "en");
                return;
            }
 
            CaseInsensitiveString RoomId = e.To.Account;
            MucRoom Room = await this.GetRoom(RoomId, e.To.Domain);
 
            if (Room is null)
            {
                await e.IqErrorItemNotFound(e.To, "Room not found.", "en");
                return;
            }
 
            MucOccupant Occupant = await this.GetOccupantByBareJid(Room, e.From.BareJid);
            StringBuilder Xml = new StringBuilder();
 
            if (!(Occupant is null) && !(Occupant.Role is null))
            {
                Xml.Append("<query xmlns='");
                Xml.Append(XmppServer.RegisterNamespace);
                Xml.Append("'><registered/><username>");
                Xml.Append(Occupant.NickName);
                Xml.Append("</username></query>");
 
                await e.IqResult(Xml.ToString(), e.To);
                return;
            }
 
            Xml.Append("<query xmlns='");
            Xml.Append(XmppServer.RegisterNamespace);
            Xml.Append("'><instructions>Fill out the form and submit it, to register in the room.</instructions><x xmlns='");
            Xml.Append(XmppServer.DataFormsNamespace);
            Xml.Append("' type='form'><title>");
            Xml.Append(string.IsNullOrEmpty(Room.Name) ? "Room" : Room.Name);
            Xml.Append(" Registration</title><instructions>Fill out the form and submit it, to register in the room.</instructions>");
            Xml.Append("<field type='hidden' var='FORM_TYPE'><value>");
            Xml.Append(FormTypeRegister);
            Xml.Append("</value></field>");
            Xml.Append("<field label='Given Name' type='text-single' var='muc#register_first'><required/>");
 
            if (!string.IsNullOrEmpty(Occupant?.FirstName))
            {
                Xml.Append("<value>");
                Xml.Append(XML.Encode(Occupant.FirstName));
                Xml.Append("</value>");
            }
 
            Xml.Append("</field>");
            Xml.Append("<field label='Family Name' type='text-single' var='muc#register_last'><required/>");
 
            if (!string.IsNullOrEmpty(Occupant?.LastName))
            {
                Xml.Append("<value>");
                Xml.Append(XML.Encode(Occupant.LastName));
                Xml.Append("</value>");
            }
 
            Xml.Append("</field>");
            Xml.Append("<field label='Desired Nickname' type='text-single' var='muc#register_roomnick'><required/>");
 
            if (!string.IsNullOrEmpty(Occupant?.NickName))
            {
                Xml.Append("<value>");
                Xml.Append(XML.Encode(Occupant.NickName));
                Xml.Append("</value>");
            }
 
            Xml.Append("</field>");
            Xml.Append("<field label='Your URL' type='text-single' var='muc#register_url'>");
 
            if (!string.IsNullOrEmpty(Occupant?.Url))
            {
                Xml.Append("<value>");
                Xml.Append(XML.Encode(Occupant.Url));
                Xml.Append("</value>");
            }
 
            Xml.Append("</field>");
            Xml.Append("<field label='Email Address' type='text-single' var='muc#register_email'>");
 
            if (!string.IsNullOrEmpty(Occupant?.EMail))
            {
                Xml.Append("<value>");
                Xml.Append(XML.Encode(Occupant.EMail));
                Xml.Append("</value>");
            }
 
            Xml.Append("</field>");
            Xml.Append("<field label='FAQ Entry' type='text-multi' var='muc#register_faqentry'>");
 
            if (!string.IsNullOrEmpty(Occupant?.FaqEntry))
            {
                Xml.Append("<value>");
                Xml.Append(XML.Encode(Occupant.FaqEntry));
                Xml.Append("</value>");
            }
 
            Xml.Append("</field>");
            Xml.Append("</x></query>");
 
            await e.IqResult(Xml.ToString(), e.To);
        }
 
        private async Task RegisterUserSubmitFormHandler(object Sender, IqEventArgs e)
        {
            if (!e.To.HasAccount)
            {
                await e.IqErrorJidMalformed(e.To, "Missing room name.", "en");
                return;
            }
 
            if (!e.To.IsBareJID)
            {
                await e.IqErrorJidMalformed(e.To, "Message must be addressed to room.", "en");
                return;
            }
 
            CaseInsensitiveString RoomId = e.To.Account;
            MucRoom Room = await this.GetRoom(RoomId, e.To.Domain);
 
            if (Room is null)
            {
                await e.IqErrorItemNotFound(e.To, "Room not found.", "en");
                return;
            }
 
            MucOccupant Occupant = await this.GetOccupantByBareJid(Room, e.From.BareJid);
            StringBuilder Xml = new StringBuilder();
 
            if (!(Occupant is null) && !(Occupant.Role is null))
            {
                Xml.Append("<query xmlns='");
                Xml.Append(XmppServer.RegisterNamespace);
                Xml.Append("'><registered/><username>");
                Xml.Append(Occupant.NickName);
                Xml.Append("</username></query>");
 
                await e.IqResult(Xml.ToString(), e.To);
                return;
            }
 
            foreach (XmlNode N in e.Query.ChildNodes)
            {
                if (N is XmlElement E && E.LocalName == "x" && E.NamespaceURI == XmppServer.DataFormsNamespace)
                {
                    string Type = XML.Attribute(E, "type");
                    if (Type == "cancel")
                    {
                        if (!(Occupant is null))
                        {
                            Room.Remove(Occupant);
 
                            if (Occupant.Persistent)
                                await Database.DeleteLazy(Occupant);
                        }
 
                        await e.IqResult(string.Empty, e.To);
                        return;
                    }
 
                    if (Type != "submit")
                    {
                        await e.IqErrorBadRequest(e.To, "Expected form submission.", "en");
                        return;
                    }
 
                    string FormType = null;
                    string FirstName = null;
                    string LastName = null;
                    string NickName = null;
                    string Url = string.Empty;
                    string EMail = string.Empty;
                    string FaqEntry = string.Empty;
 
                    foreach (XmlNode N2 in E.ChildNodes)
                    {
                        if (N2 is XmlElement E2 && E2.LocalName == "field" && E2.NamespaceURI == XmppServer.DataFormsNamespace)
                        {
                            string Name = XML.Attribute(E2, "var");
 
                            switch (Name)
                            {
                                case "FORM_TYPE":
                                    FormType = GetValue(E2);
                                    break;
 
                                case "muc#register_first":
                                    FirstName = GetValue(E2);
                                    break;
 
                                case "muc#register_last":
                                    LastName = GetValue(E2);
                                    break;
 
                                case "muc#register_roomnick":
                                    NickName = GetValue(E2);
                                    break;
 
                                case "muc#register_url":
                                    Url = GetValue(E2);
                                    break;
 
                                case "muc#register_email":
                                    EMail = GetValue(E2);
                                    break;
 
                                case "muc#register_faqentry":
                                    FaqEntry = GetValue(E2);
                                    break;
 
                                default:
                                    await e.IqErrorBadRequest(e.To, "Unknown field: " + Name, "en");
                                    return;
                            }
                        }
                    }
 
                    if (FormType is null || string.IsNullOrEmpty(FirstName) || string.IsNullOrEmpty(LastName) || string.IsNullOrEmpty(NickName))
                    {
                        await e.IqErrorBadRequest(e.To, "Missing field values.", "en");
                        return;
                    }
 
                    if (!string.IsNullOrEmpty(FormType) && FormType != FormTypeRegister)
                    {
                        await e.IqErrorBadRequest(e.To, "Unexpected FORM_TYPE.", "en");
                        return;
                    }
 
                    MucOccupant Occupant2 = await this.GetOccupantByNickName(Room, NickName);
                    if (!(Occupant2 is null) && Occupant2.BareJid != e.From.BareJid)
                    {
                        await e.IqErrorConflict(e.To, "Nick-name already taken.", "en");
                        return;
                    }
 
                    if (!(Occupant is null))
                    {
                        bool Changed = false;
 
                        if (Occupant.FirstName != FirstName)
                        {
                            Occupant.FirstName = FirstName;
                            Changed = true;
                        }
 
                        if (Occupant.LastName != LastName)
                        {
                            Occupant.LastName = LastName;
                            Changed = true;
                        }
 
                        if (Occupant.NickName != NickName)
                        {
                            Occupant.NickName = NickName;
                            Changed = true;
                        }
 
                        if (Occupant.Url != Url)
                        {
                            Occupant.Url = Url;
                            Changed = true;
                        }
 
                        if (Occupant.EMail != EMail)
                        {
                            Occupant.EMail = EMail;
                            Changed = true;
                        }
 
                        if (Occupant.FaqEntry != FaqEntry)
                        {
                            Occupant.FaqEntry = FaqEntry;
                            Changed = true;
                        }
 
                        if (Changed && Occupant.Persistent)
                            await Database.UpdateLazy(Occupant);
                    }
 
                    Xml.Append("<x xmlns='");
                    Xml.Append(XmppServer.DataFormsNamespace);
                    Xml.Append("' type='form'><title>Registration request</title>");
                    Xml.Append("<instructions>To approve this registration request, select the &quot;Allow this person to register with the room?&quot; checkbox and click OK. To skip this request, click the cancel button.</instructions>");
                    Xml.Append("<field var='FORM_TYPE' type='hidden'><value>");
                    Xml.Append(FormTypeRegister);
                    Xml.Append("</value></field>");
                    Xml.Append("<field var='muc#occupant_jid' type='hidden'><value>");
                    Xml.Append(XML.Encode(e.From.Address.Value));
                    Xml.Append("</value></field>");
                    Xml.Append("<field var='muc#register_first' type='text-single' label='Given Name'><value>");
                    Xml.Append(XML.Encode(FirstName));
                    Xml.Append("</value></field>");
                    Xml.Append("<field var='muc#register_last' type='text-single' label='Family Name'><value>");
                    Xml.Append(XML.Encode(LastName));
                    Xml.Append("</value></field>");
                    Xml.Append("<field var='muc#register_roomnick' type='text-single' label='Desired Nickname'><value>");
                    Xml.Append(XML.Encode(NickName));
                    Xml.Append("</value></field>");
                    Xml.Append("<field var='muc#register_url' type='text-single' label='User URL'><value>");
                    Xml.Append(XML.Encode(Url));
                    Xml.Append("</value></field>");
                    Xml.Append("<field var='muc#register_email' type='text-single' label='Email Address'><value>");
                    Xml.Append(XML.Encode(EMail));
                    Xml.Append("</value></field>");
                    Xml.Append("<field var='muc#register_faqentry' type='text-multi' label='FAQ Entry'><value>");
                    Xml.Append(XML.Encode(FaqEntry));
                    Xml.Append("</value></field>");
                    Xml.Append("<field var='muc#register_allow' type='boolean' label='Allow this person to register with the room?'><value>false</value></field></x>");
 
                    await this.SendToAdmin(Room, string.Empty, Xml.ToString());
 
                    await e.IqResult(string.Empty, e.To);
                    return;
                }
            }
 
            await e.IqErrorBadRequest(e.To, string.Empty, string.Empty);
        }
 
        private async Task SendToAdmin(MucRoom Room, string Type, string Xml)
        {
            Dictionary<string, bool> Sent = new Dictionary<string, bool>();
            XmppAddress From = new XmppAddress(Room.Room + "@" + Room.Domain);
 
            if (!(Room.Admins is null))
            {
                foreach (CaseInsensitiveString Jid in Room.Admins)
                {
                    if (!Sent.ContainsKey(Jid))
                    {
                        await this.Server.Message(Type, Guid.NewGuid().ToString(), new XmppAddress(Jid), From, "en", Xml, this);
                        Sent[Jid] = true;
                    }
                }
            }
 
            if (!(Room.Owners is null))
            {
                foreach (CaseInsensitiveString Jid in Room.Owners)
                {
                    if (!Sent.ContainsKey(Jid))
                    {
                        await this.Server.Message(Type, Guid.NewGuid().ToString(), new XmppAddress(Jid), From, "en", Xml, this);
                        Sent[Jid] = true;
                    }
                }
            }
        }
 
        public static async Task<string> GenerateMessageXml(string Markdown)
        {
            StringBuilder sb = new StringBuilder();
 
            sb.AppendLine("BodyOnly: 1");
            sb.AppendLine();
            sb.Append(Markdown);
 
            MarkdownDocument Doc = await MarkdownDocument.CreateAsync(sb.ToString());
            string HTML = await Doc.GenerateHTML();
            string Text = await Doc.GeneratePlainText();
 
            sb.Clear();
 
            sb.Append("<body>");
            sb.Append(XML.Encode(Text));
            sb.Append("</body>");
            sb.Append("<html xmlns='http://jabber.org/protocol/xhtml-im'>");
            sb.Append("<body xmlns='http://www.w3.org/1999/xhtml'>");
            sb.Append(HTML);
            sb.Append("</body></html>");
            sb.Append("<content xmlns='");
            sb.Append(XmppServer.ContentNamespace);
            sb.Append("' type='text/markdown'>");
            sb.Append(XML.HtmlValueEncode(Markdown));
            sb.Append("</content>");
 
            return sb.ToString();
        }
 
        protected override async Task DiscoveryQueryGet(object Sender, IqEventArgs e)
        {
            XmlElement E = e.Query;
            string Account = e.To.Account;
            MucRoom Room;
 
            if (string.IsNullOrEmpty(Account))
                Room = null;
            else
            {
                Room = await this.GetRoom(Account, e.To.Domain);
                if (Room is null)
                {
                    await e.IqErrorItemNotFound(e.To, "Item not found.", "en");
                    return;
                }
 
                if (Room.MembersOnly && !Room.IsMember(e.From.BareJid))
                {
                    await e.IqErrorBadRequest(e.To, "You are not a member of the room.", "en");
                    return;
                }
 
                if (!string.IsNullOrEmpty(e.To.Resource))
                {
                    if (!Room.TryGetOccupantFromFullJid(e.From.Address, out MucOccupant _))
                    {
                        await e.IqErrorBadRequest(e.To, "You are not in the room.", "en");
                        return;
                    }
 
                    MucOccupant Occupant = await this.GetOccupantByNickName(Room, e.To.Resource);
                    if (Occupant is null)
                    {
                        await e.IqErrorItemNotFound(e.To, "Occupant not found.", "en");
                        return;
                    }
 
                    XmppAddress[] FullJids = Occupant.FullJids;
                    if (FullJids is null || FullJids.Length == 0)
                    {
                        await e.IqErrorServiceUnavailable(e.To, "Occupant not connected.", "en");
                        return;
                    }
                    else if (FullJids.Length > 1)
                    {
                        await e.IqErrorServiceUnavailable(e.To, "Occupant connected with multiple clients.", "en");
                        return;
                    }
 
                    await this.Server.SendIqRequest("get", e.To.ToBareJID(), FullJids[0], string.Empty, InnerXmlNoJabberNamespace(e.IQ), async (sender2, e2) =>
                    {
                        if (e2.Ok)
                            await e.IqResult(InnerXmlNoJabberNamespace(e2.Response), e.To);
                        else
                            await e.IqError(e2.ErrorTypeString, e2.ErrorElement?.OuterXml ?? string.Empty, e.To, e2.ErrorText, string.Empty);
                    }, null);
 
                    return;
                }
            }
 
            string Node = XML.Attribute(E, "node");
            if (!string.IsNullOrEmpty(Node) && Node != "x-roomuser-item")
            {
                await e.IqErrorItemNotFound(e.To, "Node not found.", "en");
                return;
            }
 
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<query xmlns='");
            Xml.Append(XmppServer.DiscoveryNamespace);
            Xml.Append("'>");
 
            if (!(Room is null))
            {
                if (string.IsNullOrEmpty(Node))
                {
                    if (!string.IsNullOrEmpty(Account))
                    {
                        Xml.Append("<identity category='conference' name='");
                        Xml.Append(XML.Encode(Room.Name));
                        Xml.Append("' type='text'/>");
                    }
                }
                else
                {
                    MucOccupant Occupant = await this.GetOccupantByBareJid(Room, e.From.BareJid);
                    if (!(Occupant is null) && !string.IsNullOrEmpty(Occupant.NickName))
                    {
                        Xml.Append("<identity category='conference' name='");
                        Xml.Append(XML.Encode(Occupant.NickName));
                        Xml.Append("' type='text'/>");
                    }
                }
            }
 
            if (string.IsNullOrEmpty(Account) && string.IsNullOrEmpty(Node))
            {
                lock (this.synchObject)
                {
                    foreach (string Feature in this.features.Keys)
                    {
                        Xml.Append("<feature var='");
                        Xml.Append(XML.Encode(Feature));
                        Xml.Append("'/>");
                    }
                }
            }
 
            if (!string.IsNullOrEmpty(Account) && string.IsNullOrEmpty(Node) && !(Room is null))
            {
                Xml.Append("<feature var='http://jabber.org/protocol/muc'/>");
                Xml.Append("<feature var='");
                Xml.Append(FormTypeRegister);
                Xml.Append("'/>");
                Xml.Append("<feature var='");
                Xml.Append(FormTypeRoomConfig);
                Xml.Append("'/>");
                Xml.Append("<feature var='http://jabber.org/protocol/muc#stable_id'/>");
 
                if (Room.MembersOnly)
                    Xml.Append("<feature var='muc_membersonly'/>");
 
                if (Room.Moderated)
                    Xml.Append("<feature var='muc_moderated'/>");
                else
                    Xml.Append("<feature var='muc_unmoderated'/>");
 
                switch (Room.DiscoverRealJids)
                {
                    case DiscoverReadJids.Anyone:
                        Xml.Append("<feature var='muc_nonanonymous'/>");
                        break;
 
                    case DiscoverReadJids.Moderators:
                        Xml.Append("<feature var='muc_semianonymous'/>");
                        break;
                }
 
                if (!Room.MembersOnly)
                    Xml.Append("<feature var='muc_open'/>");
 
                if (Room.PasswordProtected)
                    Xml.Append("<feature var='muc_passwordprotected'/>");
                else
                    Xml.Append("<feature var='muc_unsecured'/>");
 
                if (Room.Persistent)
                    Xml.Append("<feature var='muc_persistent'/>");
                else
                    Xml.Append("<feature var='muc_temporary'/>");
 
                if (Room.Locked)
                    Xml.Append("<feature var='muc_hidden'/>");
                else
                    Xml.Append("<feature var='muc_public'/>");
            }
 
            Xml.Append("</query>");
 
            await e.IqResult(Xml.ToString(), e.To);
        }
 
        protected override async Task DiscoveryQueryItemsGet(object Sender, IqEventArgs e)
        {
            XmlElement E = e.Query;
            string Account = e.To.Account;
            MucRoom Room;
 
            if (string.IsNullOrEmpty(Account))
                Room = null;
            else
            {
                Room = await this.GetRoom(Account, e.To.Domain);
                if (Room is null)
                {
                    await e.IqErrorItemNotFound(e.To, "Item not found.", "en");
                    return;
                }
 
                if (Room.MembersOnly && !Room.IsMember(e.From.BareJid))
                {
                    await e.IqErrorBadRequest(e.To, "You are not a member of the room.", "en");
                    return;
                }
 
                if (!string.IsNullOrEmpty(e.To.Resource))
                {
                    if (!Room.TryGetOccupantFromFullJid(e.From.Address, out MucOccupant _))
                    {
                        await e.IqErrorBadRequest(e.To, "You are not in the room.", "en");
                        return;
                    }
 
                    MucOccupant Occupant = await this.GetOccupantByNickName(Room, e.To.Resource);
                    if (Occupant is null)
                    {
                        await e.IqErrorItemNotFound(e.To, "Occupant not found.", "en");
                        return;
                    }
 
                    XmppAddress[] FullJids = Occupant.FullJids;
                    if (FullJids is null || FullJids.Length == 0)
                    {
                        await e.IqErrorServiceUnavailable(e.To, "Occupant not connected.", "en");
                        return;
                    }
                    else if (FullJids.Length > 1)
                    {
                        await e.IqErrorServiceUnavailable(e.To, "Occupant connected with multiple clients.", "en");
                        return;
                    }
 
                    await this.Server.SendIqRequest("get", e.To.ToBareJID(), FullJids[0], string.Empty, InnerXmlNoJabberNamespace(e.IQ), async (sender2, e2) =>
                    {
                        if (e2.Ok)
                            await e.IqResult(InnerXmlNoJabberNamespace(e2.Response), e.To);
                        else
                            await e.IqError(e2.ErrorTypeString, e2.ErrorElement?.OuterXml ?? string.Empty, e.To, e2.ErrorText, string.Empty);
                    }, null);
 
                    return;
                }
            }
 
            string Node = XML.Attribute(E, "node");
            if (!string.IsNullOrEmpty(Node) && Node != "x-roomuser-item")
            {
                await e.IqErrorItemNotFound(e.To, "Node not found.", "en");
                return;
            }
 
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<query xmlns='");
            Xml.Append(XmppServer.DiscoveryItemsNamespace);
            Xml.Append("'>");
 
            if (string.IsNullOrEmpty(Node))
            {
                if (string.IsNullOrEmpty(Account))
                {
                    foreach (MucRoom Room2 in await Database.Find<MucRoom>())
                    {
                        if (!this.rooms.ContainsKey(Room2.Room))
                            this.rooms[Room2.Room] = Room2;
 
                        if (Room2.Public)
                        {
                            Xml.Append("<item jid='");
                            Xml.Append(XML.Encode(Room2.Room.Value));
                            Xml.Append('@');
                            Xml.Append(XML.Encode(Room2.Domain.Value));
                            Xml.Append("' name='");
                            Xml.Append(XML.Encode(Room2.Name));
                            Xml.Append("'/>");
                        }
                    }
                }
                else
                {
                    if (!(Room is null) &&
                        Room.Public &&
                        !Room.MembersOnly &&
                        !Room.PasswordProtected)
                    {
                        IEnumerable<MucOccupant> Occupants;
 
                        if (Room.Persistent)
                        {
                            Occupants = await Database.Find<MucOccupant>(new FilterAnd(
                                new FilterFieldEqualTo("Domain", e.To.Domain),
                                new FilterFieldEqualTo("Room", e.To.Account)));
                        }
                        else
                            Occupants = Room.GetOccupants();
 
                        foreach (MucOccupant Occupant in Occupants)
                        {
                            Xml.Append("<item jid='");
                            Xml.Append(XML.Encode(Occupant.OccupantJid.Value));
                            Xml.Append("'/>");
                        }
                    }
                }
            }
 
            Xml.Append("</query>");
 
            await e.IqResult(Xml.ToString(), e.To);
        }
 
        private async Task FormSubmissionHandler(object Sender, MessageEventArgs e)
        {
            if (e.From.IsBareJID)
            {
                await e.MessageErrorJidMalformed(e.To, "From JID must be a full JID.", "en");
                return;
            }
 
            if (!e.To.HasAccount)
            {
                await e.MessageErrorJidMalformed(e.To, "Missing room name.", "en");
                return;
            }
 
            if (!e.To.IsBareJID)
            {
                await e.MessageErrorJidMalformed(e.To, "Message must be addressed to room.", "en");
                return;
            }
 
            CaseInsensitiveString RoomId = e.To.Account;
            MucRoom Room = await this.GetRoom(RoomId, e.To.Domain);
 
            if (Room is null)
            {
                await e.MessageErrorItemNotFound(e.To, "Room not found.", "en");
                return;
            }
 
            string Type = XML.Attribute(e.Content, "type");
            if (Type == "cancel")
                return;
            else if (Type != "submit")
            {
                await e.MessageErrorBadRequest(e.To, "Expected form submission.", "en");
                return;
            }
 
            MucOccupant Occupant = await this.GetOccupantByBareJid(Room, e.From.BareJid);
            if (Occupant is null)
            {
                await e.MessageErrorForbidden(e.To, "You are not an occupant of the room.", "en");
                return;
            }
 
            string FormType = null;
 
            foreach (XmlNode N2 in e.Content.ChildNodes)
            {
                if (N2 is XmlElement E2 &&
                    E2.LocalName == "field" &&
                    E2.NamespaceURI == XmppServer.DataFormsNamespace &&
                    XML.Attribute(E2, "var") == "FORM_TYPE")
                {
                    FormType = E2["value"]?.InnerText ?? string.Empty;
                    break;
                }
            }
 
            if (FormType == FormTypeRequest)
            {
                string Role = null;
                XmppAddress Jid = null;
                string NickName = null;
                bool? Allow = null;
 
                foreach (XmlNode N2 in e.Content.ChildNodes)
                {
                    if (N2 is XmlElement E2 && E2.LocalName == "field" && E2.NamespaceURI == XmppServer.DataFormsNamespace)
                    {
                        string Name = XML.Attribute(E2, "var");
                        string Value = E2["value"]?.InnerText ?? string.Empty;
 
                        switch (Name)
                        {
                            case "FORM_TYPE":
                                break;
 
                            case "muc#role":
                                Role = Value;
                                break;
 
                            case "muc#jid":
                                Jid = new XmppAddress(Value);
                                break;
 
                            case "muc#roomnick":
                                NickName = Value;
                                break;
 
                            case "muc#request_allow":
                                if (CommonTypes.TryParse(Value, out bool b))
                                    Allow = b;
                                else
                                {
                                    await e.MessageErrorBadRequest(e.To, "Invalid boolean value.", "en");
                                    return;
                                }
                                break;
 
                            default:
                                await e.MessageErrorBadRequest(e.To, "Unknown field: " + Name, "en");
                                return;
                        }
                    }
                }
 
                if (string.IsNullOrEmpty(NickName))
                {
                    if (string.IsNullOrEmpty(Role))
                    {
                        await e.MessageErrorBadRequest(e.To, "Missing fields.", "en");
                        return;
                    }
 
                    if (Role != "moderator" && Role != "participant" && Role != "visitor" && Role != "none")
                    {
                        await e.MessageErrorBadRequest(e.To, "Invalid role.", "en");
                        return;
                    }
 
                    StringBuilder sb = new StringBuilder();
 
                    sb.Append("<x xmlns='");
                    sb.Append(XmppServer.DataFormsNamespace);
                    sb.Append("' type='form'><title>Privileges request</title>");
                    sb.Append("<instructions>To approve this request for privileges, select the ");
                    sb.Append("&quot;Grant privileges to this person?&quot; checkbox and click OK. ");
                    sb.Append("To skip this request, click the cancel button.</instructions>");
                    sb.Append("<field var='FORM_TYPE' type='hidden'><value>");
                    sb.Append(FormTypeRequest);
                    sb.Append("</value></field>");
                    sb.Append("<field var='muc#role' type='list-single' label='Requested role'><value>");
                    sb.Append(Role);
                    sb.Append("</value>");
                    sb.Append("<option label='None'><value>none</value></option>");
                    sb.Append("<option label='Visitor'><value>visitor</value></option>");
                    sb.Append("<option label='Participant'><value>participant</value></option>");
                    sb.Append("<option label='Moderator'><value>moderator</value></option></field>");
                    sb.Append("<field var='muc#jid' type='jid-single' label='JID of sender'><value>");
                    sb.Append(XML.Encode(e.From.Address));
                    sb.Append("</value></field>");
                    sb.Append("<field var='muc#roomnick' type='text-single' label='Room Nickname'><value>");
                    sb.Append(XML.Encode(Occupant.NickName));
                    sb.Append("</value></field>");
                    sb.Append("<field var='muc#request_allow' type='boolean' label='Grant privileges to this person?'><value>false</value></field></x>");
 
                    await this.SendToAdmin(Room, string.Empty, sb.ToString());
                }
                else
                {
                    if (string.IsNullOrEmpty(Role) || string.IsNullOrEmpty(NickName) || Jid is null || !Allow.HasValue)
                    {
                        await e.MessageErrorBadRequest(e.To, "Missing fields.", "en");
                        return;
                    }
 
                    if (Allow.Value)
                    {
                        if (!Room.IsModerator(Occupant))
                        {
                            await e.MessageErrorForbidden(e.To, "Insufficient privileges.", "en");
                            return;
                        }
 
                        MucOccupant Occupant2 = await this.GetOccupantByNickName(Room, NickName);
                        if (Occupant2 is null)
                        {
                            Occupant2 = new MucOccupant()
                            {
                                Room = RoomId,
                                Domain = e.To.Domain,
                                NickName = NickName,
                                BareJid = Jid.BareJid,
                                Affiliation = Room.GetDefaultAffiliation(Jid.BareJid),
                                Persistent = Room.Persistent,
                                Archive = Room.Archive
                            };
 
                            Occupant2.Role = Occupant2.Affiliation.GetDefaultRole(Room);
 
                            if (!Room.Add(Occupant2))
                            {
                                await e.MessageErrorServiceUnavailable(e.To, "Room is full.", "en");
                                return;
                            }
 
                            if (Occupant2.Persistent)
                                await Database.InsertLazy(Occupant2);
                        }
                        else
                        {
                            if (Occupant2.BareJid != Jid.BareJid)
                            {
                                await e.MessageErrorConflict(e.To, "Nick-name belongs to a different occupant.", "en");
                                return;
                            }
                        }
 
                        switch (Role)
                        {
                            case "none":
                                Occupant2.Role = new Roles.None();
                                break;
 
                            case "visitor":
                                Occupant2.Role = new Visitor();
                                break;
 
                            case "participant":
                                Occupant2.Role = new Participant();
                                break;
 
                            case "moderator":
                                Occupant2.Role = new Moderator();
                                break;
 
                            default:
                                await e.MessageErrorBadRequest(e.To, "Unrecognized role.", "en");
                                return;
                        }
 
                        if (Occupant2.Persistent)
                            await Database.UpdateLazy(Occupant2);
 
                        XmppAddress OccupantJid = new XmppAddress(Occupant2.OccupantJid);
                        StringBuilder sb = new StringBuilder();
                        XmppAddress[] Jids0 = Occupant2.FullJids;
                        XmppAddress[] Jids;
                        string Xml;
 
                        if (Jids0 is null || Jids0.Length == 0)
                            Jids0 = new XmppAddress[] { null };
 
                        foreach (MucOccupant Occupant3 in Room.GetOccupants())
                        {
                            if (Room.CanDiscoverRealJids(Occupant3))
                                Jids = Jids0;
                            else
                                Jids = new XmppAddress[] { null };
 
                            foreach (XmppAddress Jid2 in Jids)
                            {
                                sb.Append("<x xmlns='");
                                sb.Append(NamespaceMucUser);
                                sb.Append("'><item affiliation='");
                                sb.Append(Occupant2.Affiliation.Name);
 
                                if (!(Jid2 is null))
                                {
                                    sb.Append("' jid='");
                                    sb.Append(XML.Encode(Jid2.Address));
                                }
 
                                sb.Append("' role='");
                                sb.Append(Occupant2.Role?.Name ?? "none");
                                sb.Append("'><actor nick='");
                                sb.Append(XML.Encode(NickName));
                                sb.Append("'/>");
                                sb.Append("</item>");
                                sb.Append("</x>");
 
                                Xml = sb.ToString();
                                sb.Clear();
 
                                if (!(Occupant3.FullJids is null))
                                {
                                    foreach (XmppAddress FullJid in Occupant3.FullJids)
                                        await this.Server.Presence(string.Empty, Guid.NewGuid().ToString(), FullJid, OccupantJid, string.Empty, Xml, this);
                                }
                            }
                        }
                    }
                }
            }
            else if (FormType == FormTypeRegister)
            {
                string FirstName = null;
                string LastName = null;
                string NickName = null;
                string Url = string.Empty;
                string EMail = string.Empty;
                string FaqEntry = string.Empty;
                string FullJid = string.Empty;
                bool? Allow = null;
 
                foreach (XmlNode N2 in e.Content.ChildNodes)
                {
                    if (N2 is XmlElement E2 && E2.LocalName == "field" && E2.NamespaceURI == XmppServer.DataFormsNamespace)
                    {
                        string Name = XML.Attribute(E2, "var");
 
                        switch (Name)
                        {
                            case "FORM_TYPE":
                                break;
 
                            case "muc#occupant_jid":
                                FullJid = GetValue(E2);
                                break;
 
                            case "muc#register_first":
                                FirstName = GetValue(E2);
                                break;
 
                            case "muc#register_last":
                                LastName = GetValue(E2);
                                break;
 
                            case "muc#register_roomnick":
                                NickName = GetValue(E2);
                                break;
 
                            case "muc#register_url":
                                Url = GetValue(E2);
                                break;
 
                            case "muc#register_email":
                                EMail = GetValue(E2);
                                break;
 
                            case "muc#register_faqentry":
                                FaqEntry = GetValue(E2);
                                break;
 
                            case "muc#register_allow":
                                if (CommonTypes.TryParse(GetValue(E2), out bool b))
                                    Allow = b;
                                else
                                {
                                    await e.MessageErrorBadRequest(e.To, "Invalid boolean value.", "en");
                                    return;
                                }
                                break;
 
                            default:
                                await e.MessageErrorBadRequest(e.To, "Unknown field: " + Name, "en");
                                return;
                        }
                    }
                }
 
                if (FormType is null ||
                    string.IsNullOrEmpty(FirstName) ||
                    string.IsNullOrEmpty(LastName) ||
                    string.IsNullOrEmpty(NickName) ||
                    string.IsNullOrEmpty(FullJid) ||
                    !Allow.HasValue)
                {
                    await e.MessageErrorBadRequest(e.To, "Missing fields.", "en");
                    return;
                }
 
                if (!Room.IsModerator(Occupant))
                {
                    await e.MessageErrorForbidden(e.To, "Insufficient privileges.", "en");
                    return;
                }
 
                XmppAddress From = new XmppAddress(FullJid);
                MucOccupant Occupant2 = await this.GetOccupantByBareJid(Room, From.BareJid);
 
                if (Allow.Value)
                {
                    if (Occupant2 is null)
                    {
                        Occupant2 = new MucOccupant()
                        {
                            Room = RoomId,
                            Domain = e.To.Domain,
                            NickName = NickName,
                            BareJid = From.BareJid,
                            FullJids = new XmppAddress[] { From },
                            Affiliation = Room.GetDefaultAffiliation(From.BareJid),
                            Persistent = Room.Persistent,
                            Archive = Room.Archive,
                            FirstName = FirstName,
                            LastName = LastName,
                            Url = Url,
                            EMail = EMail,
                            FaqEntry = FaqEntry
                        };
 
                        Occupant2.Role = Occupant2.Affiliation.GetDefaultRole(Room) ?? new Visitor();
 
                        if (!Room.Add(Occupant2))
                        {
                            await e.MessageErrorServiceUnavailable(e.To, "Room is full.", "en");
                            return;
                        }
 
                        if (Occupant2.Persistent)
                            await Database.InsertLazy(Occupant2);
                    }
                    else
                    {
                        Occupant2.NickName = NickName;
                        Occupant2.FullJids = new XmppAddress[] { From };
                        Occupant2.Persistent = Room.Persistent;
                        Occupant2.Archive = Room.Archive;
                        Occupant2.FirstName = FirstName;
                        Occupant2.LastName = LastName;
                        Occupant2.Url = Url;
                        Occupant2.EMail = EMail;
                        Occupant2.FaqEntry = FaqEntry;
 
                        if (Occupant2.Role is null)
                            Occupant2.Role = new Visitor();
 
                        if (Occupant2.Persistent)
                            await Database.UpdateLazy(Occupant2);
                    }
 
                    await this.OccupantEntered(Room, Occupant2, From, false, string.Empty, null);
                }
                else
                {
                    Room.Remove(Occupant2);
 
                    if (Occupant2.Persistent)
                        await Database.DeleteLazy(Occupant2);
                }
            }
            else
            {
                await e.MessageErrorBadRequest(e.To, "Unexpected FORM_TYPE.", "en");
                return;
            }
        }
 
        private async Task AdminCommandHandler(object Sender, IqEventArgs e)
        {
            if (e.From.IsBareJID)
            {
                await e.IqErrorJidMalformed(e.To, "From JID must be a full JID.", "en");
                return;
            }
 
            if (!e.To.HasAccount)
            {
                await e.IqErrorJidMalformed(e.To, "Missing room name.", "en");
                return;
            }
 
            if (!e.To.IsBareJID)
            {
                await e.IqErrorJidMalformed(e.To, "Message must be addressed to room.", "en");
                return;
            }
 
            CaseInsensitiveString RoomId = e.To.Account;
            MucRoom Room = await this.GetRoom(RoomId, e.To.Domain);
 
            if (Room is null)
            {
                await e.IqErrorItemNotFound(e.To, "Room not found.", "en");
                return;
            }
 
            if (!Room.TryGetOccupantFromFullJid(e.From.Address, out MucOccupant Occupant))
            {
                await e.IqErrorForbidden(e.To, "Not an occupant of room.", "en");
                return;
            }
 
            foreach (XmlNode N in e.Query.ChildNodes)
            {
                if (!(N is XmlElement E) || E.NamespaceURI != NamespaceMucAdmin)
                    continue;
 
                switch (E.LocalName)
                {
                    case "item":
                        string NickName = XML.Attribute(E, "nick");
                        string Jid = XML.Attribute(E, "jid");
                        string Role = XML.Attribute(E, "role");
                        string Affiliation = XML.Attribute(E, "affiliation");
 
                        if (!Room.IsModerator(Occupant))
                        {
                            await e.IqErrorForbidden(e.To, "Insufficient privileges.", "en");
                            return;
                        }
 
                        MucOccupant Occupant2;
 
                        if (string.IsNullOrEmpty(Affiliation))
                            Occupant2 = await this.GetOccupantByNickName(Room, NickName);
                        else
                            Occupant2 = await this.GetOccupantByBareJid(Room, Jid);
 
                        if (Occupant2 is null)
                        {
                            if (string.IsNullOrEmpty(Affiliation))
                                await e.IqErrorItemNotFound(e.To, "Occupant with specified nick-name not found in room.", "en");
                            else
                                await e.IqErrorItemNotFound(e.To, "Occupant with specified jid not found in room.", "en");
 
                            return;
                        }
 
                        if ((Room.IsAdmin(Occupant2) && !Room.IsAdmin(Occupant)) ||
                            (Room.IsOwner(Occupant2) && !Room.IsOwner(Occupant)))
                        {
                            await e.IqErrorNotAllowed(e.To, "Higher affiliation required.", "en");
                            return;
                        }
 
                        bool Kicked = false;
                        bool Outcast = false;
                        bool Removed = false;
                        bool RoomUpdated = false;
                        string Type = string.Empty;
 
                        Occupant2.Reason = string.Empty;
 
                        if (!string.IsNullOrEmpty(Role))
                        {
                            switch (Role)
                            {
                                case "none":
                                    if (Occupant.BareJid == Occupant2.BareJid)
                                    {
                                        await e.IqErrorNotAllowed(e.To, "You cannot kick yourself.", "en");
                                        return;
                                    }
 
                                    Occupant2.Role = new Roles.None();
                                    Type = "unavailable";
                                    Kicked = true;
                                    break;
 
                                case "visitor":
                                    Occupant2.Role = new Visitor();
                                    break;
 
                                case "participant":
                                    Occupant2.Role = new Participant();
                                    break;
 
                                case "moderator":
                                    Occupant2.Role = new Moderator();
                                    break;
 
                                default:
                                    await e.IqErrorBadRequest(e.To, "Unrecognized role.", "en");
                                    return;
                            }
                        }
 
                        if (!string.IsNullOrEmpty(Affiliation))
                        {
                            int NrOwnersBefore = Room.Owners.Length;
 
                            if (Room.IsOwner(Occupant2))
                            {
                                if (Occupant.BareJid == Occupant2.BareJid)
                                {
                                    await e.IqErrorNotAllowed(e.To, "You cannot disown yourself.", "en");
                                    return;
                                }
 
                                Room.RemoveOwner(Occupant2.BareJid);
                                RoomUpdated = true;
                            }
 
                            if (Room.IsAdmin(Occupant2))
                            {
                                Room.RemoveAdmin(Occupant2.BareJid);
                                RoomUpdated = true;
                            }
 
                            switch (Affiliation)
                            {
                                case "none":
                                    if (Occupant.BareJid == Occupant2.BareJid)
                                    {
                                        await e.IqErrorNotAllowed(e.To, "You cannot kick yourself.", "en");
                                        return;
                                    }
 
                                    Occupant2.Affiliation = new Affiliations.None();
 
                                    if (Room.MembersOnly)
                                    {
                                        Removed = true;
                                        Room.Remove(Occupant);
                                        Type = "unavailable";
                                    }
                                    break;
 
                                case "member":
                                    Occupant2.Affiliation = new Member();
                                    break;
 
                                case "admin":
                                    Occupant2.Affiliation = new Affiliations.Admin();
                                    Room.AddAdmin(Occupant2.BareJid);
                                    RoomUpdated = true;
                                    break;
 
                                case "owner":
                                    Occupant2.Affiliation = new Owner();
                                    Room.AddOwner(Occupant2.BareJid);
                                    RoomUpdated = true;
                                    break;
 
                                case "outcast":
                                    Room.Remove(Occupant);
                                    Occupant2.Affiliation = new Outcast();
                                    Outcast = true;
                                    Type = "unavailable";
                                    break;
 
                                default:
                                    await e.IqErrorBadRequest(e.To, "Unrecognized affiliation.", "en");
                                    return;
                            }
 
                            int NrOwnersAfter = Room.Owners.Length;
 
                            if (NrOwnersAfter == 0 && NrOwnersBefore > 0)
                            {
                                if (Room.Persistent)
                                    this.rooms.Remove(RoomId);
 
                                Room.AddOwner(Occupant2.BareJid);
                                await e.IqErrorNotAcceptable(e.To, "Room must have at least one owner.", "en");
                                return;
                            }
                        }
 
 
                        foreach (XmlNode N2 in E.ChildNodes)
                        {
                            if (N2 is XmlElement E2 && E2.LocalName == "reason" && E2.NamespaceURI == NamespaceMucAdmin)
                            {
                                Occupant2.Reason = E2.InnerText;
                                break;
                            }
                        }
 
                        if (Occupant2.Persistent)
                            await Database.UpdateLazy(Occupant2);
 
                        if (RoomUpdated && Room.Persistent)
                            await Database.UpdateLazy(Room);
 
                        StringBuilder Xml = new StringBuilder();
                        string ToSelf;
                        string ToOthers;
 
                        Xml.Append("<x xmlns='");
                        Xml.Append(NamespaceMucUser);
                        Xml.Append("'><item affiliation='");
                        Xml.Append(Occupant2.Affiliation.Name);
                        Xml.Append("' role='");
                        Xml.Append(Occupant2.Role?.Name ?? "none");
                        Xml.Append("'><actor nick='");
                        Xml.Append(XML.Encode(Occupant2.NickName));
                        Xml.Append("'/>");
 
                        if (!string.IsNullOrEmpty(Occupant2.Reason))
                        {
                            Xml.Append("<reason>");
                            Xml.Append(XML.Encode(Occupant2.Reason));
                            Xml.Append("</reason>");
                        }
 
                        Xml.Append("</item>");
 
                        if (Outcast)
                            Xml.Append("<status code='301'/>");
 
                        if (Kicked)
                            Xml.Append("<status code='307'/>");
 
                        if (Removed)
                            Xml.Append("<status code='321'/>");
 
                        StringBuilder Xml2 = new StringBuilder();
                        Xml2.Append(Xml.ToString());
                        Xml2.Append("</x>");
                        Xml.Append("</x>");
 
                        ToSelf = Xml2.ToString();
                        ToOthers = Xml.ToString();
 
                        XmppAddress OccupantJid = new XmppAddress(Occupant2.OccupantJid);
 
                        foreach (MucOccupant Occupant3 in Room.GetOccupants())
                        {
                            if (!(Occupant3.FullJids is null))
                            {
                                foreach (XmppAddress FullJid in Occupant3.FullJids)
                                {
                                    await this.Server.Presence(Type, Guid.NewGuid().ToString(), FullJid, OccupantJid, string.Empty,
                                        FullJid == e.From ? ToSelf : ToOthers, this);
                                }
                            }
                        }
 
                        if (Kicked)
                            Room.Remove(Occupant2);
                        break;
                }
            }
 
            await e.IqResult(string.Empty, e.To);
        }
 
        private async Task AdminQueryHandler(object Sender, IqEventArgs e)
        {
            if (e.From.IsBareJID)
            {
                await e.IqErrorJidMalformed(e.To, "From JID must be a full JID.", "en");
                return;
            }
 
            if (!e.To.HasAccount)
            {
                await e.IqErrorJidMalformed(e.To, "Missing room name.", "en");
                return;
            }
 
            if (!e.To.IsBareJID)
            {
                await e.IqErrorJidMalformed(e.To, "Message must be addressed to room.", "en");
                return;
            }
 
            CaseInsensitiveString RoomId = e.To.Account;
            MucRoom Room = await this.GetRoom(RoomId, e.To.Domain);
 
            if (Room is null)
            {
                await e.IqErrorItemNotFound(e.To, "Room not found.", "en");
                return;
            }
 
            if (!Room.TryGetOccupantFromFullJid(e.From.Address, out MucOccupant Occupant))
            {
                await e.IqErrorForbidden(e.To, "Not an occupant of room.", "en");
                return;
            }
 
            foreach (XmlNode N in e.Query.ChildNodes)
            {
                if (!(N is XmlElement E) || E.NamespaceURI != NamespaceMucAdmin)
                    continue;
 
                switch (E.LocalName)
                {
                    case "item":
                        string Role = XML.Attribute(E, "role");
                        string Affiliation = XML.Attribute(E, "affiliation");
 
                        if (!Room.IsModerator(Occupant))
                        {
                            await e.IqErrorForbidden(e.To, "Insufficient privileges.", "en");
                            return;
                        }
 
                        IEnumerable<MucOccupant> Occupants;
 
                        if (!string.IsNullOrEmpty(Role))
                        {
                            if (Room.Persistent)
                            {
                                Occupants = await Database.Find<MucOccupant>(new FilterAnd(
                                    new FilterFieldEqualTo("Domain", e.To.Domain),
                                    new FilterFieldEqualTo("Room", e.To.Account),
                                    new FilterCustom<MucOccupant>(o => (o.Role?.Name ?? "none") == Role)));
                            }
                            else
                            {
                                Occupants = from Occupant2 in Room.GetOccupants()
                                            where (Occupant2.Role?.Name ?? "none") == Role
                                            select Occupant2;
                            }
                        }
                        else if (!string.IsNullOrEmpty(Affiliation))
                        {
                            if (Room.Persistent)
                            {
                                Occupants = await Database.Find<MucOccupant>(new FilterAnd(
                                    new FilterFieldEqualTo("Domain", e.To.Domain),
                                    new FilterFieldEqualTo("Room", e.To.Account),
                                    new FilterCustom<MucOccupant>(o => (o.Affiliation?.Name ?? "none") == Affiliation)));
                            }
                            else
                            {
                                Occupants = from Occupant2 in Room.GetOccupants()
                                            where (Occupant2.Affiliation?.Name ?? "none") == Role
                                            select Occupant2;
                            }
                        }
                        else
                            Occupants = new MucOccupant[0];
 
                        StringBuilder Xml = new StringBuilder();
                        XmppAddress[] Jids;
 
                        Xml.Append("<query xmlns='");
                        Xml.Append(NamespaceMucAdmin);
                        Xml.Append("'>");
 
                        foreach (MucOccupant Occupant2 in Occupants)
                        {
                            if (Room.DiscoverRealJids == DiscoverReadJids.None ||
                                !Room.TryGetOccupantFromNick(Occupant2.NickName, out MucOccupant Occupant3))
                            {
                                Jids = new XmppAddress[] { null };
                            }
                            else
                            {
                                Jids = Occupant3.FullJids;
                                if (Jids is null || Jids.Length == 0)
                                    Jids = new XmppAddress[] { null };
                            }
 
                            foreach (XmppAddress Jid in Jids)
                            {
                                Xml.Append("<item affiliation='");
                                Xml.Append(Occupant2.Affiliation?.Name ?? "none");
 
                                if (Occupant2.Affiliation is Outcast)
                                {
                                    Xml.Append("' jid='");
                                    if (Jid is null)
                                        Xml.Append(XML.Encode(Occupant2.BareJid));
                                    else
                                        Xml.Append(XML.Encode(Jid.Address.Value));
                                }
                                else
                                {
                                    if (!(Jid is null))
                                    {
                                        Xml.Append("' jid='");
                                        Xml.Append(XML.Encode(Jid.Address.Value));
                                    }
 
                                    Xml.Append("' nick='");
                                    Xml.Append(XML.Encode(Occupant2.NickName));
                                    Xml.Append("' role='");
                                    Xml.Append(Occupant2.Role?.Name ?? "none");
                                }
 
                                if (string.IsNullOrEmpty(Occupant2.Reason))
                                    Xml.Append("'/>");
                                else
                                {
                                    Xml.Append("'><reason>");
                                    Xml.Append(XML.Encode(Occupant2.Reason));
                                    Xml.Append("</reason></item>");
                                }
                            }
                        }
 
                        Xml.Append("</query>");
 
                        await e.IqResult(Xml.ToString(), e.To);
                        break;
                }
            }
        }
 
        private async Task OwnerQueryHandler(object Sender, IqEventArgs e)
        {
            if (!e.To.HasAccount)
            {
                await e.IqErrorJidMalformed(e.To, "Missing room name.", "en");
                return;
            }
 
            if (!e.To.IsBareJID)
            {
                await e.IqErrorJidMalformed(e.To, "Message must be addressed to room.", "en");
                return;
            }
 
            CaseInsensitiveString RoomId = e.To.Account;
            MucRoom Room = await this.GetRoom(RoomId, e.To.Domain);
 
            if (Room is null)
            {
                await e.IqErrorItemNotFound(e.To, "Room not found.", "en");
                return;
            }
 
            if (!Room.IsOwner(e.From.BareJid))
            {
                await e.IqErrorForbidden(e.To, "You're not an owner of this room.", "en");
                return;
            }
 
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<query xmlns='");
            Xml.Append(NamespaceMucOwner);
            Xml.Append("'><x xmlns='jabber:x:data' type='form'>");
            Xml.Append("<title>Configuration for ");
            Xml.Append(XML.Encode(RoomId));
            Xml.Append(" Room</title>");
            Xml.Append("<instructions>Enter room configuration below, then click OK.</instructions>");
            Xml.Append("<field type='hidden' var='FORM_TYPE'><value>");
            Xml.Append(FormTypeRoomConfig);
            Xml.Append("</value></field>");
            Xml.Append("<field label='Natural-Language Room Name' type='text-single' var='muc#roomconfig_roomname'><value>");
            Xml.Append(XML.Encode(Room.Name));
            Xml.Append("</value></field>");
            Xml.Append("<field label='Short Description of Room' type='text-single' var='muc#roomconfig_roomdesc'><value>");
            Xml.Append(XML.Encode(Room.Description));
            Xml.Append("</value></field>");
            Xml.Append("<field label='Natural Language for Room Discussions' type='text-single' var='muc#roomconfig_lang'><value>");
            Xml.Append(XML.Encode(Room.Language));
            Xml.Append("</value></field>");
            Xml.Append("<field label='Enable Public Logging?' type='boolean' var='muc#roomconfig_enablelogging'><value>");
            Xml.Append(Room.Logging ? "1" : "0");
            Xml.Append("</value></field>");
            Xml.Append("<field label='Allow Occupants to Change Subject?' type='boolean' var='muc#roomconfig_changesubject'><value>");
            Xml.Append(Room.AllowChangeSubject ? "1" : "0");
            Xml.Append("</value></field>");
            Xml.Append("<field label='Allow Occupants to Invite Others?' type='boolean' var='muc#roomconfig_allowinvites'><value>");
            Xml.Append(Room.AllowInvites ? "1" : "0");
            Xml.Append("</value></field>");
            Xml.Append("<field label='Who Can Send Private Messages?' type='list-single' var='muc#roomconfig_allowpm'><value>");
            Xml.Append(Room.AllowPrivateMessages.ToString().ToLower());
            Xml.Append("</value>");
            Xml.Append("<option label='Anyone'><value>anyone</value></option>");
            Xml.Append("<option label='Anyone with Voice'><value>participants</value></option>");
            Xml.Append("<option label='Moderators Only'><value>moderators</value></option>");
            Xml.Append("<option label='Nobody'><value>none</value></option></field>");
            Xml.Append("<field label='Maximum Number of Occupants' type='list-single' var='muc#roomconfig_maxusers'><value>");
            Xml.Append(Room.MaxHistoryFetch == int.MaxValue ? "none" : Room.MaxHistoryFetch.ToString());
            Xml.Append("</value>");
            Xml.Append("<option label='10'><value>10</value></option>");
            Xml.Append("<option label='20'><value>20</value></option>");
            Xml.Append("<option label='30'><value>30</value></option>");
            Xml.Append("<option label='50'><value>50</value></option>");
            Xml.Append("<option label='100'><value>100</value></option>");
            Xml.Append("<option label='None'><value>none</value></option></field>");
            Xml.Append("<field label='Roles for which Presence is Broadcasted' type='list-multi' var='muc#roomconfig_presencebroadcast'>");
            if (Room.PresenceBroadcast.HasFlag(BroadcastPresence.Moderator))
                Xml.Append("<value>moderator</value>");
            if (Room.PresenceBroadcast.HasFlag(BroadcastPresence.Participant))
                Xml.Append("<value>participant</value>");
            if (Room.PresenceBroadcast.HasFlag(BroadcastPresence.Visitor))
                Xml.Append("<value>visitor</value>");
            Xml.Append("<option label='Moderator'><value>moderator</value></option>");
            Xml.Append("<option label='Participant'><value>participant</value></option>");
            Xml.Append("<option label='Visitor'><value>visitor</value></option></field>");
            Xml.Append("<field label='Roles and Affiliations that May Retrieve Member List' type='list-multi' var='muc#roomconfig_getmemberlist'>");
            if (Room.GetMemberList.HasFlag(RetrieveMembershipList.Moderator))
                Xml.Append("<value>moderator</value>");
            if (Room.GetMemberList.HasFlag(RetrieveMembershipList.Participant))
                Xml.Append("<value>participant</value>");
            if (Room.GetMemberList.HasFlag(RetrieveMembershipList.Visitor))
                Xml.Append("<value>visitor</value>");
            Xml.Append("<option label='Moderator'><value>moderator</value></option>");
            Xml.Append("<option label='Participant'><value>participant</value></option>");
            Xml.Append("<option label='Visitor'><value>visitor</value></option></field>");
            Xml.Append("<field label='Make Room Publicly Searchable?' type='boolean' var='muc#roomconfig_publicroom'><value>");
            Xml.Append(Room.Public ? "1" : "0");
            Xml.Append("</value></field>");
            Xml.Append("<field label='Make Room Persistent?' type='boolean' var='muc#roomconfig_persistentroom'><value>");
            Xml.Append(Room.Persistent ? "1" : "0");
            Xml.Append("</value></field>");
            Xml.Append("<field label='Make Room Moderated?' type='boolean' var='muc#roomconfig_moderatedroom'><value>");
            Xml.Append(Room.Moderated ? "1" : "0");
            Xml.Append("</value></field>");
            Xml.Append("<field label='Make Room Members-Only?' type='boolean' var='muc#roomconfig_membersonly'><value>");
            Xml.Append(Room.MembersOnly ? "1" : "0");
            Xml.Append("</value></field>");
            Xml.Append("<field label='Password Required to Enter?' type='boolean' var='muc#roomconfig_passwordprotectedroom'><value>");
            Xml.Append(Room.PasswordProtected ? "1" : "0");
            Xml.Append("</value></field>");
            Xml.Append("<field type='fixed'><value>If a password is required to enter this room, you must specify the password below.</value></field>");
            Xml.Append("<field label='Password' type='text-private' var='muc#roomconfig_roomsecret'><value>");
            Xml.Append(XML.Encode(Room.Password));
            Xml.Append("</value></field>");
            Xml.Append("<field label='Who May Discover Real JIDs?' type='list-single' var='muc#roomconfig_whois'><value>");
            Xml.Append(Room.DiscoverRealJids.ToString().ToLower());
            Xml.Append("</value>");
            Xml.Append("<option label='No-one'><value>none</value></option>");
            Xml.Append("<option label='Moderators Only'><value>moderators</value></option>");
            Xml.Append("<option label='Anyone'><value>anyone</value></option></field>");
            Xml.Append("<field label='Maximum Number of History Messages Returned by Room' type='text-single' var='muc#maxhistoryfetch'><value>");
            Xml.Append(Room.MaxHistoryFetch.ToString());
            Xml.Append("</value></field>");
            Xml.Append("<field type='fixed'><value>You may specify additional people who have admin status in the room. Please provide one Jabber ID per line.</value></field>");
            Xml.Append("<field label='Room Admins' type='jid-multi' var='muc#roomconfig_roomadmins'>");
            if (!(Room.Admins is null))
            {
                foreach (CaseInsensitiveString Jid in Room.Admins)
                {
                    Xml.Append("<value>");
                    Xml.Append(XML.Encode(Jid.Value));
                    Xml.Append("</value>");
                }
            }
            Xml.Append("</field>");
            Xml.Append("<field type='fixed'><value>You may specify additional owners for this room. Please provide one Jabber ID per line.</value></field>");
            Xml.Append("<field label='Room Owners' type='jid-multi' var='muc#roomconfig_roomowners'>");
            if (!(Room.Owners is null))
            {
                foreach (CaseInsensitiveString Jid in Room.Owners)
                {
                    Xml.Append("<value>");
                    Xml.Append(XML.Encode(Jid.Value));
                    Xml.Append("</value>");
                }
            }
            Xml.Append("</field></x></query>");
 
            await e.IqResult(Xml.ToString(), e.To);
        }
 
        private async Task OwnerCommandHandler(object Sender, IqEventArgs e)
        {
            if (!e.To.HasAccount)
            {
                await e.IqErrorJidMalformed(e.To, "Missing room name.", "en");
                return;
            }
 
            if (!e.To.IsBareJID)
            {
                await e.IqErrorJidMalformed(e.To, "Message must be addressed to room.", "en");
                return;
            }
 
            CaseInsensitiveString RoomId = e.To.Account;
            MucRoom Room = await this.GetRoom(RoomId, e.To.Domain);
 
            if (Room is null)
            {
                await e.IqErrorItemNotFound(e.To, "Room not found.", "en");
                return;
            }
 
            if (!Room.IsOwner(e.From.BareJid))
            {
                await e.IqErrorForbidden(e.To, "You're not an owner of this room.", "en");
                return;
            }
 
            foreach (XmlNode N in e.Query.ChildNodes)
            {
                if (!(N is XmlElement E))
                    continue;
 
                if (E.LocalName == "destroy" && E.NamespaceURI == NamespaceMucOwner)
                {
                    string AlternativeRoomJid = XML.Attribute(E, "jid");
                    string Reason = null;
                    string Password = null;
 
                    foreach (XmlNode N2 in E.ChildNodes)
                    {
                        if (!(N2 is XmlElement E2))
                            continue;
 
                        switch (E2.LocalName)
                        {
                            case "reason":
                                Reason = E2.InnerText;
                                break;
 
                            case "password":
                                Password = E2.InnerText;
                                break;
                        }
                    }
 
                    if (Room.PasswordProtected && (Password is null || Room.Password != Password))
                    {
                        await e.IqErrorNotAuthorized(e.To, "Room ID or password incorrect.", "en");
                        return;
                    }
 
                    StringBuilder sb = new StringBuilder();
 
                    sb.Append("<x xmlns='");
                    sb.Append(NamespaceMucUser);
                    sb.Append("'><item affiliation='none' role='none'/><destroy");
 
                    if (!string.IsNullOrEmpty(AlternativeRoomJid))
                    {
                        sb.Append(" jid='");
                        sb.Append(XML.Encode(AlternativeRoomJid));
                        sb.Append("'");
                    }
 
                    sb.Append('>');
 
                    if (!string.IsNullOrEmpty(Reason))
                    {
                        sb.Append("<reason>");
                        sb.Append(XML.Encode(Reason));
                        sb.Append("</reason>");
                    }
 
                    sb.Append("</destroy></x>");
 
                    string Xml = sb.ToString();
 
                    await Database.StartBulk();
                    try
                    {
                        foreach (MucOccupant Occupant2 in Room.GetOccupants())
                        {
                            foreach (XmppAddress Jid in Occupant2.FullJids)
                            {
                                await this.Server.Presence("unavailable", Guid.NewGuid().ToString(), Jid,
                                    new XmppAddress(Occupant2.OccupantJid), string.Empty, Xml, this);
 
                                if (Occupant2.Persistent)
                                    await Database.DeleteLazy(Occupant2);
 
                                Room.Remove(Occupant2);
                            }
                        }
 
                        if (Room.Persistent)
                            await Database.DeleteLazy(Room);
                    }
                    finally
                    {
                        await Database.EndBulk();
                    }
 
                    if (Room.Persistent && Room.Logging)
                    {
                        await Database.FindDelete<MucMessage>(new FilterAnd(
                            new FilterFieldEqualTo("Domain", e.To.Domain),
                            new FilterFieldEqualTo("Room", RoomId)));
                    }
 
                    Log.Informational("Room destroyed", RoomId, e.From.BareJid,
                        new KeyValuePair<string, object>("Room", RoomId),
                        new KeyValuePair<string, object>("Domain", e.To.Domain),
                        new KeyValuePair<string, object>("Destroyer", e.From.BareJid));
 
                    await e.IqResult(string.Empty, e.To);
                }
                else if (E.LocalName == "x" && E.NamespaceURI == XmppServer.DataFormsNamespace)
                {
                    string Type = XML.Attribute(E, "type");
                    if (Type == "submit")
                    {
                        CanSendPrivateMessages? PrivateMessages = null;
                        DiscoverReadJids? DiscoverJids = null;
                        BroadcastPresence? PresenceBroadcast = null;
                        RetrieveMembershipList? GetMemberList = null;
                        string FormType = null;
                        string RoomName = null;
                        string RoomDescription = null;
                        string RoomLanguage = null;
                        string Password = null;
                        CaseInsensitiveString[] Administrators = null;
                        CaseInsensitiveString[] Owners = null;
                        int? MaxUsers = null;
                        int? MaxHistory = null;
                        bool? Logging = null;
                        bool? ChangeSubject = null;
                        bool? AllowInvites = null;
                        bool? Public = null;
                        bool? Persist = null;
                        bool? Moderated = null;
                        bool? MembersOnly = null;
                        bool? PasswordProtected = null;
                        bool InvalidBoolean = false;
                        bool InvalidInt = false;
                        bool InvalidEnum = false;
 
                        foreach (XmlNode N2 in E.ChildNodes)
                        {
                            if (N2 is XmlElement E2 && E2.LocalName == "field" && E2.NamespaceURI == XmppServer.DataFormsNamespace)
                            {
                                string Name = XML.Attribute(E2, "var");
 
                                switch (Name)
                                {
                                    case "FORM_TYPE":
                                        FormType = GetValue(E2);
                                        break;
 
                                    case "muc#roomconfig_roomname":
                                        RoomName = GetValue(E2);
                                        break;
 
                                    case "muc#roomconfig_roomdesc":
                                        RoomDescription = GetValue(E2);
                                        break;
 
                                    case "muc#roomconfig_lang":
                                        RoomLanguage = GetValue(E2);
                                        break;
 
                                    case "muc#roomconfig_enablelogging":
                                        if (CommonTypes.TryParse(GetValue(E2), out bool b))
                                            Logging = b;
                                        else
                                            InvalidBoolean = true;
                                        break;
 
                                    case "muc#roomconfig_changesubject":
                                        if (CommonTypes.TryParse(GetValue(E2), out b))
                                            ChangeSubject = b;
                                        else
                                            InvalidBoolean = true;
                                        break;
 
                                    case "muc#roomconfig_allowinvites":
                                        if (CommonTypes.TryParse(GetValue(E2), out b))
                                            AllowInvites = b;
                                        else
                                            InvalidBoolean = true;
                                        break;
 
                                    case "muc#roomconfig_allowpm":
                                        switch (GetValue(E2))
                                        {
                                            case "anyone":
                                                PrivateMessages = CanSendPrivateMessages.Anyone;
                                                break;
 
                                            case "participants":
                                                PrivateMessages = CanSendPrivateMessages.Participants;
                                                break;
 
                                            case "moderators":
                                                PrivateMessages = CanSendPrivateMessages.Moderators;
                                                break;
 
                                            case "none":
                                                PrivateMessages = CanSendPrivateMessages.None;
                                                break;
 
                                            default:
                                                InvalidEnum = true;
                                                break;
                                        }
                                        break;
 
                                    case "muc#roomconfig_maxusers":
                                        string s = GetValue(E2);
                                        if (int.TryParse(s, out int i))
                                            MaxUsers = i;
                                        else if (s == "none")
                                            MaxUsers = int.MaxValue;
                                        else
                                            InvalidInt = true;
                                        break;
 
                                    case "muc#roomconfig_publicroom":
                                        if (CommonTypes.TryParse(GetValue(E2), out b))
                                            Public = b;
                                        else
                                            InvalidBoolean = true;
                                        break;
 
                                    case "muc#roomconfig_persistentroom":
                                        if (CommonTypes.TryParse(GetValue(E2), out b))
                                            Persist = b;
                                        else
                                            InvalidBoolean = true;
                                        break;
 
                                    case "muc#roomconfig_moderatedroom":
                                        if (CommonTypes.TryParse(GetValue(E2), out b))
                                            Moderated = b;
                                        else
                                            InvalidBoolean = true;
                                        break;
 
                                    case "muc#roomconfig_membersonly":
                                        if (CommonTypes.TryParse(GetValue(E2), out b))
                                            MembersOnly = b;
                                        else
                                            InvalidBoolean = true;
                                        break;
 
                                    case "muc#roomconfig_passwordprotectedroom":
                                        if (CommonTypes.TryParse(GetValue(E2), out b))
                                            PasswordProtected = b;
                                        else
                                            InvalidBoolean = true;
                                        break;
 
                                    case "muc#roomconfig_roomsecret":
                                        Password = GetValue(E2);
                                        break;
 
                                    case "muc#roomconfig_presencebroadcast":
                                        PresenceBroadcast = BroadcastPresence.None;
                                        foreach (CaseInsensitiveString Choice in GetValues(E2))
                                        {
                                            switch (Choice.LowerCase)
                                            {
                                                case "moderator":
                                                    PresenceBroadcast |= BroadcastPresence.Moderator;
                                                    break;
 
                                                case "participant":
                                                    PresenceBroadcast |= BroadcastPresence.Participant;
                                                    break;
 
                                                case "visitor":
                                                    PresenceBroadcast |= BroadcastPresence.Visitor;
                                                    break;
 
                                                default:
                                                    InvalidEnum = true;
                                                    break;
                                            }
                                        }
                                        break;
 
                                    case "muc#roomconfig_getmemberlist":
                                        GetMemberList = RetrieveMembershipList.None;
                                        foreach (CaseInsensitiveString Choice in GetValues(E2))
                                        {
                                            switch (Choice.LowerCase)
                                            {
                                                case "moderator":
                                                    GetMemberList |= RetrieveMembershipList.Moderator;
                                                    break;
 
                                                case "participant":
                                                    GetMemberList |= RetrieveMembershipList.Participant;
                                                    break;
 
                                                case "visitor":
                                                    GetMemberList |= RetrieveMembershipList.Visitor;
                                                    break;
 
                                                default:
                                                    InvalidEnum = true;
                                                    break;
                                            }
                                        }
                                        break;
 
                                    case "muc#roomconfig_whois":
                                        switch (GetValue(E2))
                                        {
                                            case "anyone":
                                                DiscoverJids = DiscoverReadJids.Anyone;
                                                break;
 
                                            case "moderators":
                                                DiscoverJids = DiscoverReadJids.Moderators;
                                                break;
 
                                            case "none":
                                                DiscoverJids = DiscoverReadJids.None;
                                                break;
 
                                            default:
                                                InvalidEnum = true;
                                                break;
                                        }
                                        break;
 
                                    case "muc#maxhistoryfetch":
                                        if (int.TryParse(GetValue(E2), out i))
                                            MaxHistory = i;
                                        else
                                            InvalidInt = true;
                                        break;
 
                                    case "muc#roomconfig_roomadmins":
                                        Administrators = GetValues(E2);
                                        break;
 
                                    case "muc#roomconfig_roomowners":
                                        Owners = GetValues(E2);
                                        if (Owners.Length == 0)
                                        {
                                            await e.IqErrorConflict(e.To, "Room must have owners.", "en");
                                            return;
                                        }
                                        break;
 
                                    default:
                                        await e.IqErrorBadRequest(e.To, "Unknown field: " + Name, "en");
                                        return;
                                }
                            }
                        }
 
                        if (InvalidBoolean)
                        {
                            await e.IqErrorBadRequest(e.To, "Invalid boolean value.", "en");
                            return;
                        }
 
                        if (InvalidInt)
                        {
                            await e.IqErrorBadRequest(e.To, "Invalid integer value.", "en");
                            return;
                        }
 
                        if (InvalidEnum)
                        {
                            await e.IqErrorBadRequest(e.To, "Invalid option.", "en");
                            return;
                        }
 
                        if (!string.IsNullOrEmpty(FormType) && FormType != FormTypeRoomConfig)
                        {
                            await e.IqErrorBadRequest(e.To, "Invalid or unexpected FORM_TYPE.", "en");
                            return;
                        }
 
                        CaseInsensitiveString[] OldAdmins = null;
                        CaseInsensitiveString[] OldOwners = null;
                        bool NameChanged = false;
                        bool DescriptionChanged = false;
                        bool LanguageChanged = false;
                        bool LoggingChanged = false;
                        bool ChangeSubjectChanged = false;
                        bool AllowInvitesChanged = false;
                        bool PrivateMessagesChanged = false;
                        bool MaxOccupantsChanged = false;
                        bool PresenceBroadcastChanged = false;
                        bool MembershipListChanged = false;
                        bool PersistentChanged = false;
                        bool ModeratedChanged = false;
                        bool MembersOnlyChanged = false;
                        bool PublicChanged = false;
                        bool PasswordProtectedChanged = false;
                        bool PasswordChanged = false;
                        bool DiscoverJidsChanged = false;
                        bool MaxHistoryChanged = false;
                        bool AdminsChanged = false;
                        bool OwnersChanged = false;
                        SortedDictionary<int, bool> StatusChange = null;
 
                        if (!(RoomName is null) && Room.Name != RoomName)
                        {
                            Room.Name = RoomName;
                            NameChanged = true;
                            this.AddStatus(ref StatusChange, 104);
                        }
 
                        if (!(RoomDescription is null) && Room.Description != RoomDescription)
                        {
                            Room.Description = RoomDescription;
                            DescriptionChanged = true;
                            this.AddStatus(ref StatusChange, 104);
                        }
 
                        if (!(RoomLanguage is null) && Room.Language != RoomLanguage)
                        {
                            Room.Language = RoomLanguage;
                            LanguageChanged = true;
                            this.AddStatus(ref StatusChange, 104);
                        }
 
                        if (Logging.HasValue && Logging.Value != Room.Logging)
                        {
                            Room.Logging = Logging.Value;
                            LoggingChanged = true;
                            this.AddStatus(ref StatusChange, Room.Logging ? 170 : 171);
                            this.AddStatus(ref StatusChange, 104);
                        }
 
                        if (ChangeSubject.HasValue && ChangeSubject.Value != Room.AllowChangeSubject)
                        {
                            Room.AllowChangeSubject = ChangeSubject.Value;
                            ChangeSubjectChanged = true;
                            this.AddStatus(ref StatusChange, 104);
                        }
 
                        if (AllowInvites.HasValue && AllowInvites.Value != Room.AllowInvites)
                        {
                            Room.AllowInvites = AllowInvites.Value;
                            AllowInvitesChanged = true;
                            this.AddStatus(ref StatusChange, 104);
                        }
 
                        if (PrivateMessages.HasValue && PrivateMessages.Value != Room.AllowPrivateMessages)
                        {
                            Room.AllowPrivateMessages = PrivateMessages.Value;
                            PrivateMessagesChanged = true;
                            this.AddStatus(ref StatusChange, 104);
                        }
 
                        if (MaxUsers.HasValue && MaxUsers.Value != Room.MaxOccupants)
                        {
                            Room.MaxOccupants = MaxUsers.Value;
                            MaxOccupantsChanged = true;
                            this.AddStatus(ref StatusChange, 104);
                        }
 
                        if (PresenceBroadcast.HasValue && PresenceBroadcast.Value != Room.PresenceBroadcast)
                        {
                            Room.PresenceBroadcast = PresenceBroadcast.Value;
                            PresenceBroadcastChanged = true;
                            this.AddStatus(ref StatusChange, 104);
                        }
 
                        if (GetMemberList.HasValue && GetMemberList.Value != Room.GetMemberList)
                        {
                            Room.GetMemberList = GetMemberList.Value;
                            MembershipListChanged = true;
                            this.AddStatus(ref StatusChange, 104);
                        }
 
                        if (Persist.HasValue && Persist.Value != Room.Persistent)
                        {
                            Room.Persistent = Persist.Value;
                            PersistentChanged = true;
                            this.AddStatus(ref StatusChange, 104);
                        }
 
                        if (Moderated.HasValue && Moderated.Value != Room.Moderated)
                        {
                            Room.Moderated = Moderated.Value;
                            ModeratedChanged = true;
                            this.AddStatus(ref StatusChange, 104);
                        }
 
                        if (MembersOnly.HasValue && MembersOnly.Value != Room.MembersOnly)
                        {
                            Room.MembersOnly = MembersOnly.Value;
                            MembersOnlyChanged = true;
                            this.AddStatus(ref StatusChange, 104);
                        }
 
                        if (Public.HasValue && Public.Value != Room.Public)
                        {
                            Room.Public = Public.Value;
                            PublicChanged = true;
                            this.AddStatus(ref StatusChange, 104);
                        }
 
                        if (PasswordProtected.HasValue && PasswordProtected.Value != Room.PasswordProtected)
                        {
                            Room.PasswordProtected = PasswordProtected.Value;
                            PasswordProtectedChanged = true;
                            this.AddStatus(ref StatusChange, 104);
                        }
 
                        if (!(Password is null) && Password != Room.Password)
                        {
                            Room.Password = Password;
                            PasswordChanged = true;
                            this.AddStatus(ref StatusChange, 104);
                        }
 
                        if (DiscoverJids.HasValue && DiscoverJids.Value != Room.DiscoverRealJids)
                        {
                            Room.DiscoverRealJids = DiscoverJids.Value;
                            DiscoverJidsChanged = true;
                            this.AddStatus(ref StatusChange, 104);
 
                            switch (Room.DiscoverRealJids)
                            {
                                case DiscoverReadJids.Anyone:
                                    this.AddStatus(ref StatusChange, 172);
                                    break;
 
                                case DiscoverReadJids.Moderators:
                                    this.AddStatus(ref StatusChange, 173);
                                    break;
                            }
                        }
 
                        if (MaxHistory.HasValue && MaxHistory.Value != Room.MaxHistoryFetch)
                        {
                            Room.MaxHistoryFetch = MaxHistory.Value;
                            MaxHistoryChanged = true;
                            this.AddStatus(ref StatusChange, 104);
                        }
 
                        if (!(Administrators is null) && !AreEqual(Room.Admins, Administrators))
                        {
                            if (!(Room.Admins is null))
                            {
                                foreach (CaseInsensitiveString Jid in Room.Admins)
                                {
                                    if (Array.IndexOf(Administrators, Jid) < 0)
                                    {
                                        MucOccupant Occupant = await this.GetOccupantByBareJid(Room, Jid);
                                        if (!(Occupant is null))
                                        {
                                            Occupant.Affiliation = new Member();
                                            Occupant.Role = new Participant();
 
                                            if (Occupant.Persistent)
                                                await Database.UpdateLazy(Occupant);
 
                                            await this.PresenceUserXmlToAll(Room, Occupant);
                                        }
                                    }
                                }
                            }
 
                            OldAdmins = Room.Admins ?? new CaseInsensitiveString[0];
                            Room.Admins = Administrators;
                            AdminsChanged = true;
                            this.AddStatus(ref StatusChange, 104);
                        }
 
                        if (!(Owners is null) && !AreEqual(Room.Owners, Owners))
                        {
                            if (!(Room.Owners is null))
                            {
                                foreach (CaseInsensitiveString Jid in Room.Owners)
                                {
                                    if (Array.IndexOf(Owners, Jid) < 0)
                                    {
                                        MucOccupant Occupant = await this.GetOccupantByBareJid(Room, Jid);
                                        if (!(Occupant is null))
                                        {
                                            Occupant.Affiliation = new Member();
                                            Occupant.Role = new Participant();
 
                                            if (Occupant.Persistent)
                                                await Database.UpdateLazy(Occupant);
 
                                            await this.PresenceUserXmlToAll(Room, Occupant);
                                        }
                                    }
                                }
                            }
 
                            OldOwners = Room.Owners ?? new CaseInsensitiveString[0];
                            Room.Owners = Owners;
                            OwnersChanged = true;
                            this.AddStatus(ref StatusChange, 104);
                        }
 
                        if (AdminsChanged)
                        {
                            foreach (CaseInsensitiveString Jid in Administrators)
                            {
                                if (Array.IndexOf(OldAdmins, Jid) < 0)
                                {
                                    MucOccupant Occupant = await this.GetOccupantByBareJid(Room, Jid);
                                    if (!(Occupant is null))
                                    {
                                        Occupant.Affiliation = new Affiliations.Admin();
                                        Occupant.Role = new Moderator();
 
                                        if (Occupant.Persistent)
                                            await Database.UpdateLazy(Occupant);
 
                                        await this.PresenceUserXmlToAll(Room, Occupant);
                                    }
                                }
                            }
                        }
 
                        if (OwnersChanged)
                        {
                            foreach (CaseInsensitiveString Jid in Owners)
                            {
                                if (Array.IndexOf(OldOwners, Jid) < 0)
                                {
                                    MucOccupant Occupant = await this.GetOccupantByBareJid(Room, Jid);
                                    if (!(Occupant is null))
                                    {
                                        Occupant.Affiliation = new Owner();
                                        Occupant.Role = new Moderator();
 
                                        if (Occupant.Persistent)
                                            await Database.UpdateLazy(Occupant);
 
                                        await this.PresenceUserXmlToAll(Room, Occupant);
                                    }
                                }
                            }
                        }
 
                        bool Created = Room.Locked;
                        Room.Locked = false;
 
                        if (Room.Persistent)
                        {
                            if (string.IsNullOrEmpty(Room.ObjectID))
                                await Database.InsertLazy(Room);
                            else
                                await Database.UpdateLazy(Room);
 
                            if (Created)
                            {
                                foreach (MucOccupant Occupant in Room.GetOccupants())
                                {
                                    if (!Occupant.Persistent)
                                    {
                                        Occupant.Persistent = true;
 
                                        if (string.IsNullOrEmpty(Occupant.ObjectID))
                                            await Database.InsertLazy(Occupant);
                                        else
                                            await Database.UpdateLazy(Occupant);
                                    }
                                }
                            }
                        }
 
                        await e.IqResult(string.Empty, e.To);
 
                        StringBuilder sb = new StringBuilder();
 
                        if (!(StatusChange is null))
                        {
                            sb.Append("<x xmlns='");
                            sb.Append(NamespaceMucUser);
                            sb.Append("'>");
 
                            foreach (int Code in StatusChange.Keys)
                            {
                                sb.Append("<status code='");
                                sb.Append(Code.ToString());
                                sb.Append("'/>");
                            }
 
                            sb.Append("</x>");
 
                            await this.PresenceXmlToAll(Room, sb.ToString());
 
                            sb.Clear();
                        }
 
                        sb.Append("| ");
                        if (Created)
                            sb.Append("Room Created");
                        else
                            sb.Append("Room Configuration Updated");
 
                        sb.AppendLine(" ||");
                        sb.AppendLine("|:-----|:------|");
                        sb.Append("| Room: | `");
                        sb.Append(Room.Room);
                        sb.AppendLine("` |");
                        sb.Append("| Domain: | `");
                        sb.Append(Room.Domain);
                        sb.AppendLine("` |");
                        sb.Append("| Creator: | `");
                        sb.Append(Room.Creator);
                        sb.AppendLine("` |");
                        sb.Append("| Name: | ");
                        sb.Append(BoldIfChanged(MarkdownDocument.Encode(OneRow(Room.Name)), NameChanged));
                        sb.AppendLine(" |");
                        sb.Append("| Description: | ");
                        sb.Append(BoldIfChanged(MarkdownDocument.Encode(OneRow(Room.Description)), DescriptionChanged));
                        sb.AppendLine(" |");
                        sb.Append("| Language: | ");
                        sb.Append(BoldIfChanged(MarkdownDocument.Encode(OneRow(Room.Language)), LanguageChanged));
                        sb.AppendLine(" |");
                        sb.Append("| Logging: | ");
                        sb.Append(BoldIfChanged(OneRow(Room.Logging), LoggingChanged));
                        sb.AppendLine(" |");
                        sb.Append("| Allow Change of Subject: | ");
                        sb.Append(BoldIfChanged(OneRow(Room.AllowChangeSubject), ChangeSubjectChanged));
                        sb.AppendLine(" |");
                        sb.Append("| Allow Invites: | ");
                        sb.Append(BoldIfChanged(OneRow(Room.AllowInvites), AllowInvitesChanged));
                        sb.AppendLine(" |");
                        sb.Append("| Private Messages: | ");
                        sb.Append(BoldIfChanged(OneRow(Room.AllowPrivateMessages), PrivateMessagesChanged));
                        sb.AppendLine(" |");
                        sb.Append("| Max Occupants: | ");
                        sb.Append(BoldIfChanged(Room.MaxOccupants == int.MaxValue ? "No limit" : Room.MaxOccupants.ToString(), MaxOccupantsChanged));
                        sb.AppendLine(" |");
                        sb.Append("| Presence Broadcast: | ");
                        sb.Append(BoldIfChanged(OneRow(Room.PresenceBroadcast), PresenceBroadcastChanged));
                        sb.AppendLine(" |");
                        sb.Append("| Membership List: | ");
                        sb.Append(BoldIfChanged(OneRow(Room.GetMemberList), MembershipListChanged));
                        sb.AppendLine(" |");
                        sb.Append("| Persistent: | ");
                        sb.Append(BoldIfChanged(OneRow(Room.Persistent), PersistentChanged));
                        sb.AppendLine(" |");
                        sb.Append("| Moderated: | ");
                        sb.Append(BoldIfChanged(OneRow(Room.Moderated), ModeratedChanged));
                        sb.AppendLine(" |");
                        sb.Append("| Members-Only: | ");
                        sb.Append(BoldIfChanged(OneRow(Room.MembersOnly), MembersOnlyChanged));
                        sb.AppendLine(" |");
                        sb.Append("| Public: | ");
                        sb.Append(BoldIfChanged(OneRow(Room.Public), PublicChanged));
                        sb.AppendLine(" |");
                        sb.Append("| Password protection: | ");
                        sb.Append(BoldIfChanged(OneRow(Room.PasswordProtected), PasswordProtectedChanged));
                        sb.AppendLine(" |");
                        sb.Append("| Password: | ");
                        sb.Append(BoldIfChanged(OneRow(!string.IsNullOrEmpty(Room.Password)), PasswordChanged));
                        sb.AppendLine(" |");
                        sb.Append("| Discover JIDs: | ");
                        sb.Append(BoldIfChanged(OneRow(Room.DiscoverRealJids), DiscoverJidsChanged));
                        sb.AppendLine(" |");
                        sb.Append("| Max History: | ");
                        sb.Append(BoldIfChanged(OneRow(Room.MaxHistoryFetch.ToString()), MaxHistoryChanged));
                        sb.AppendLine(" |");
                        sb.Append("| Administrators: | ");
                        sb.Append(BoldIfChanged(OneRow(Room.Admins), AdminsChanged));
                        sb.AppendLine(" |");
                        sb.Append("| Owners: | ");
                        sb.Append(BoldIfChanged(OneRow(Room.Owners), OwnersChanged));
                        sb.AppendLine(" |");
 
                        await this.SendToAdmin(Room, "chat", await GenerateMessageXml(sb.ToString()));
                    }
                    else if (Type == "cancel")
                    {
                        if (Room.Locked)
                            this.rooms.Remove(RoomId);
 
                        await e.IqResult(string.Empty, e.To);
                    }
                    else
                        await e.IqErrorBadRequest(e.To, "Unexpected form type.", "en");
                }
            }
        }
 
        private void AddStatus(ref SortedDictionary<int, bool> Codes, int Code)
        {
            if (Codes is null)
                Codes = new SortedDictionary<int, bool>();
 
            Codes[Code] = true;
        }
 
        private async Task PresenceUserXmlToAll(MucRoom Room, MucOccupant Occupant)
        {
            XmppAddress From = new XmppAddress(Occupant.OccupantJid);
 
            foreach (MucOccupant Occupant2 in Room.GetOccupants())
            {
                if (!(Occupant2.FullJids is null))
                {
                    foreach (XmppAddress Jid in Occupant2.FullJids)
                    {
                        if (Room.CanDiscoverRealJids(Occupant2) && !(Occupant.FullJids is null) && Occupant.FullJids.Length > 0)
                        {
                            foreach (XmppAddress FullJid in Occupant.FullJids)
                            {
                                await this.Server.Presence(string.Empty, Guid.NewGuid().ToString(), Jid, From, string.Empty,
                                    Occupant.GetUserXml(FullJid.Address, Occupant.NickName), this);
                            }
                        }
                        else
                        {
                            await this.Server.Presence(string.Empty, Guid.NewGuid().ToString(), Jid, From, string.Empty,
                                Occupant.GetUserXml(null, Occupant.NickName), this);
                        }
                    }
                }
            }
        }
 
        private Task PresenceXmlToAll(MucRoom Room, string Xml)
        {
            XmppAddress From = new XmppAddress(Room.Room + "@" + Room.Domain);
            return this.PresenceXmlToAll(From, Room.GetOccupants(), Xml);
        }
 
        private async Task PresenceXmlToAll(XmppAddress From, MucOccupant[] Occupants, string Xml)
        {
            foreach (MucOccupant Occupant2 in Occupants)
            {
                if (!(Occupant2.FullJids is null))
                {
                    foreach (XmppAddress Jid in Occupant2.FullJids)
                        await this.Server.Presence(string.Empty, Guid.NewGuid().ToString(), Jid, From, string.Empty, Xml, this);
                }
            }
        }
 
        private static string OneRow(CaseInsensitiveString[] Strings)
        {
            if (Strings is null)
                return string.Empty;
 
            StringBuilder sb = new StringBuilder();
            bool First = true;
 
            foreach (CaseInsensitiveString s in Strings)
            {
                if (First)
                    First = false;
                else
                    sb.Append("<br/>");
 
                sb.Append('`');
                sb.Append(s.Value);
                sb.Append('`');
            }
 
            return sb.ToString();
        }
 
        private static bool AreEqual(Array A1, Array A2)
        {
            if ((A1 is null) ^ (A2 is null))
                return false;
 
            if (A1 is null)
                return true;
 
            int c = A1.Length;
            if (A2.Length != c)
                return false;
 
            int i;
 
            for (i = 0; i < c; i++)
            {
                if (!A1.GetValue(i).Equals(A2.GetValue(i)))
                    return false;
            }
 
            return true;
        }
 
        private static string BoldIfChanged(string s, bool Changed)
        {
            return Changed ? "**" + s + "**" : s;
        }
 
        private static string OneRow(Enum e)
        {
            return "`" + e.ToString() + "`";
        }
 
        private static string OneRow(bool b)
        {
            return b ? "✔" : "✗";
        }
 
        private static string OneRow(string s)
        {
            return s.Replace("\r\n", "\n").Replace('\r', '\n').Replace('\n', ' ');
        }
 
        private static string GetValue(XmlElement E)
        {
            foreach (XmlNode N in E.ChildNodes)
            {
                if (N is XmlElement E2 && E2.LocalName == "value" && E.NamespaceURI == E2.NamespaceURI)
                    return E2.InnerText;
            }
 
            return string.Empty;
        }
 
        private static CaseInsensitiveString[] GetValues(XmlElement E)
        {
            List<CaseInsensitiveString> Values = new List<CaseInsensitiveString>();
 
            foreach (XmlNode N in E.ChildNodes)
            {
                if (N is XmlElement E2 && E2.LocalName == "value" && E.NamespaceURI == E2.NamespaceURI)
                    Values.Add(E2.InnerText);
            }
 
            return Values.ToArray();
        }
 
        private async Task SelfPingHandler(object Sender, IqEventArgs e)
        {
            CaseInsensitiveString NickName = e.To.Resource;
            if (CaseInsensitiveString.IsNullOrEmpty(NickName))
            {
                await e.IqErrorBadRequest(e.To, "Nick-name missing.", "en");
                return;
            }
 
            if (!e.From.IsFullJID)
            {
                await e.IqErrorBadRequest(e.To, "Sender not an XMPP client.", "en");
                return;
            }
 
            MucRoom Room = await this.GetRoom(e.To.Account, e.To.Domain);
            if (Room is null)
            {
                await e.IqErrorNotAcceptable(e.To, "Room not found.", "en");
                return;
            }
 
            if (!Room.TryGetOccupantFromNick(e.To.Resource, out MucOccupant Occupant) || !Occupant.ContainsFullJid(e.From))
            {
                await e.IqErrorNotAcceptable(e.To, "Occupant not in room.", "en");
                return;
            }
 
            await e.IqResult(string.Empty, e.To);
        }
 
    }
}