public MappedIdentity MapUser(OpenMetaverse.UUID SlId, string SlName = null)
        {
            var identity = new MappedIdentity(IdentityCategory.Agent);

            identity.AvatarID = SlId;

            if (SlName != null && !UsernameToKeyCache.ContainsKey(SlName))
            {
                identity.SlName            = SlName;
                UsernameToKeyCache[SlName] = SlId;
                KeyToUsernameCache[SlId]   = SlName;
            }

            if (KeyToUsernameCache.ContainsKey(SlId))
            {
                identity.SlName = KeyToUsernameCache[SlId];
            }
            else
            {
                identity.SlName = ResolveNameFromId(SlId);
            }

            identity.IrcNick   = MakeIrcName(identity.SlName, ".");
            identity.IrcIdent  = SlId.ToString();
            identity.IrcDomain = AGENTHOST;

            return(identity);
        }
        internal static IntermediateMessage ClientNotice(MappedIdentity sender, string payload)
        {
            var msg = new IntermediateMessage(sender, MessageType.ClientNotice);

            msg.Payload = payload;
            return(msg);
        }
Exemple #3
0
 private void SendOnline(MappedIdentity mappedFriend)
 {
     if (config.PresenceNotices)
     {
         downstream.SendFromServer("NOTICE", downstream.ClientNick, "[PRESENCE] {0:IrcNick} is now online".Format(mappedFriend));
     }
     else
     {
         downstream.SendNumeric(Numeric.RPL_MONONLINE, mappedFriend.IrcNick);
     }
 }
        public Task <MappedIdentity> MapObject(UUID slId, string SlName)
        {
            var identity = new MappedIdentity(IdentityCategory.Object);

            identity.SlName    = SlName ?? "Object";
            identity.AvatarID  = slId;
            identity.IrcNick   = String.Join(".", SlName.Split(' '));;
            identity.IrcIdent  = slId.ToString();
            identity.IrcDomain = "object." + gridDomain;

            return(Task.FromResult(identity));
        }
        public MappedIdentity MapObject(OpenMetaverse.UUID SlId, string SlName)
        {
            var identity = new MappedIdentity(IdentityCategory.Object);

            identity.SlName    = SlName;
            identity.AvatarID  = SlId;
            identity.IrcNick   = MakeIrcName(SlName, ".");
            identity.IrcIdent  = "object";
            identity.IrcDomain = OBJECTHOST;

            return(identity);
        }
        public void SendMessageTo(MappedIdentity destination, IntermediateMessage msg)
        {
            UUID session;

            if (!oneOnOnesessions.TryGetValue(destination.AvatarID, out session))
            {
                oneOnOnesessions[destination.AvatarID] = client.Self.AgentID ^ destination.AvatarID;
            }

            client.Self.InstantMessage(client.Self.Name, destination.AvatarID, msg.Payload,
                                       session, InstantMessageDialog.MessageFromAgent, InstantMessageOnline.Online,
                                       client.Self.SimPosition, client.Network.CurrentSim.ID, null);
        }
        public IdentityMapperAsync(GridClient Client, string GridDomain)
        {
            client     = Client;
            gridDomain = GridDomain;

            grid           = new MappedIdentity(IdentityCategory.System);
            grid.AvatarID  = UUID.Zero;
            grid.IrcDomain = gridDomain;
            grid.SlName    = gridDomain;
            grid.IrcNick   = gridDomain;

            clientIdentity = new System.Lazy <MappedIdentity>(() =>
            {
                return(MakeAgentIdentity(client.Self.AgentID, client.Self.Name));
            });

            client.Avatars.UUIDNameReply  += Avatars_UUIDNameReply;
            client.Groups.GroupNamesReply += Groups_GroupNamesReply;
        }
        public IdentityMapperAsync(GridClient Client, string GridDomain)
        {
            client = Client;
            gridDomain = GridDomain;

            grid = new MappedIdentity(IdentityCategory.System);
            grid.AvatarID = UUID.Zero;
            grid.IrcDomain = gridDomain;
            grid.SlName = gridDomain;
            grid.IrcNick = gridDomain;

            clientIdentity = new System.Lazy<MappedIdentity>(() =>
            {
                return MakeAgentIdentity(client.Self.AgentID, client.Self.Name);
            });

            client.Avatars.UUIDNameReply += Avatars_UUIDNameReply;
            client.Groups.GroupNamesReply += Groups_GroupNamesReply;
        }
        public MappedIdentity MapUser(string IrcName)
        {
            var identity = new MappedIdentity(IdentityCategory.Agent);

            identity.IrcNick   = IrcName;
            identity.IrcIdent  = "agent";
            identity.IrcDomain = AGENTHOST;
            identity.SlName    = String.Join(" ", IrcName.Split('.'));

            if (UsernameToKeyCache.ContainsKey(IrcName))
            {
                identity.AvatarID = UsernameToKeyCache[identity.SlName];
            }
            else
            {
                identity.AvatarID = ResolveIdFromName(identity.SlName);
            }
            return(identity);
        }
        public IdentityMapper(string gridName, GridClient client)
        {
            this.client             = client;
            this.gridName           = gridName.CamelCase();
            this.UsernameToKeyCache = new Dictionary <string, UUID>();
            this.KeyToUsernameCache = new Dictionary <UUID, string>();
            this.IrcToGroupCache    = new Dictionary <string, UUID>();
            this.GroupToIrcCache    = new Dictionary <UUID, string>();

            gridIdentity           = new MappedIdentity(IdentityCategory.System);
            gridIdentity.AvatarID  = UUID.Zero;
            gridIdentity.IrcNick   = "**SYSTEM**";
            gridIdentity.IrcIdent  = gridName;
            gridIdentity.IrcDomain = "grid.sl";
            gridIdentity.SlName    = gridName;

            clientIdentity           = new MappedIdentity(IdentityCategory.System);
            clientIdentity.AvatarID  = UUID.Zero;
            clientIdentity.IrcDomain = "local.sl";
        }
        public IdentityMapper(string gridName, GridClient client)
        {
            this.client = client;
            this.gridName = gridName.CamelCase();
            this.UsernameToKeyCache = new Dictionary<string, UUID>();
            this.KeyToUsernameCache = new Dictionary<UUID, string>();
            this.IrcToGroupCache = new Dictionary<string, UUID>();
            this.GroupToIrcCache = new Dictionary<UUID, string>();

            gridIdentity = new MappedIdentity(IdentityCategory.System);
            gridIdentity.AvatarID = UUID.Zero;
            gridIdentity.IrcNick = "**SYSTEM**";
            gridIdentity.IrcIdent = gridName;
            gridIdentity.IrcDomain = "grid.sl";
            gridIdentity.SlName = gridName;

            clientIdentity = new MappedIdentity(IdentityCategory.System);
            clientIdentity.AvatarID = UUID.Zero;
            clientIdentity.IrcDomain = "local.sl";
        }
        private IEnumerable <MappedIdentity> MakeAgentIdentities(Dictionary <UUID, string> queries)
        {
            var results = new List <MappedIdentity>();

            lock (agentCacheLock) {
                foreach (var i in queries)
                {
                    MappedIdentity newid;

                    if (!AgentsByUuid.TryGetValue(i.Key, out newid))
                    {
                        newid           = new MappedIdentity(IdentityCategory.Agent);
                        newid.AvatarID  = i.Key;
                        newid.SlName    = i.Value;
                        newid.IrcNick   = String.Join(".", i.Value.Split(' '));
                        newid.IrcIdent  = i.Key.ToString();
                        newid.IrcDomain = agentSubdomain + "." + gridDomain;

                        AgentsByIrcNick[newid.IrcNick] = newid;
                        AgentsByUuid[i.Key]            = newid;
                    }

                    results.Add(newid);
                }
            }

            lock (agentRequests)
            {
                var fulfilledRequests = from req in agentRequests
                                        from res in results
                                        where req.AgentId == res.AvatarID || req.SlName == res.SlName
                                        select new { Request = req, Response = res };
                foreach (var i in fulfilledRequests.ToList())
                {
                    agentRequests.Remove(i.Request);
                    i.Request.TaskSource.SetResult(i.Response);
                }
            }
            return(results);
        }
        private IEnumerable<MappedIdentity> MakeAgentIdentities(Dictionary<UUID, string> queries)
        {
            var results = new List<MappedIdentity>();
            lock(agentCacheLock) {
                foreach(var i in queries)
                {
                    MappedIdentity newid;

                    if (!AgentsByUuid.TryGetValue(i.Key, out newid))
                    {
                        newid = new MappedIdentity(IdentityCategory.Agent);
                        newid.AvatarID = i.Key;
                        newid.SlName = i.Value;
                        newid.IrcNick = String.Join(".", i.Value.Split(' '));
                        newid.IrcIdent = i.Key.ToString();
                        newid.IrcDomain = agentSubdomain + "." + gridDomain;

                        AgentsByIrcNick[newid.IrcNick] = newid;
                        AgentsByUuid[i.Key] = newid;
                    }

                    results.Add(newid);
                }
            }

            lock (agentRequests)
            {
                var fulfilledRequests = from req in agentRequests
                                        from res in results
                                        where req.AgentId == res.AvatarID || req.SlName == res.SlName
                                        select new { Request = req, Response = res };
                foreach (var i in fulfilledRequests.ToList())
                {
                    agentRequests.Remove(i.Request);
                    i.Request.TaskSource.SetResult(i.Response);
                }
            }
            return results;
        }
        public MappedIdentity MapUser(string IrcName)
        {
            var identity = new MappedIdentity(IdentityCategory.Agent);
            identity.IrcNick = IrcName;
            identity.IrcIdent = "agent";
            identity.IrcDomain = AGENTHOST;
            identity.SlName = String.Join(" ", IrcName.Split('.'));

            if(UsernameToKeyCache.ContainsKey(IrcName))
            {
                identity.AvatarID = UsernameToKeyCache[identity.SlName];
            }
            else
            {
                identity.AvatarID = ResolveIdFromName(identity.SlName);
            }
            return identity;
        }
 public IntermediateMessage(MappedIdentity sender, MessageType messageType)
 {
     this.Sender = sender;
     this.Type   = messageType;
 }
 private void SendOnline(MappedIdentity mappedFriend)
 {
     if (config.PresenceNotices)
     {
         downstream.SendFromServer("NOTICE", downstream.ClientNick, "[PRESENCE] {0:IrcNick} is now online".Format(mappedFriend));
     }
     else
     {
         downstream.SendNumeric(Numeric.RPL_MONONLINE, mappedFriend.IrcNick);
     }
 }
 public MappedIdentity MapUser(MappedIdentity Identity)
 {
     return(Identity);
 }
        public MappedIdentity MapUser(OpenMetaverse.UUID SlId, string SlName = null)
        {
            var identity = new MappedIdentity(IdentityCategory.Agent);
            identity.AvatarID = SlId;

            if(SlName != null && !UsernameToKeyCache.ContainsKey(SlName))
            {
                identity.SlName = SlName;
                UsernameToKeyCache[SlName] = SlId;
                KeyToUsernameCache[SlId] = SlName;
            }

            if(KeyToUsernameCache.ContainsKey(SlId))
            {
                identity.SlName = KeyToUsernameCache[SlId];
            }
            else
            {
                identity.SlName = ResolveNameFromId(SlId);
            }

            identity.IrcNick = MakeIrcName(identity.SlName, ".");
            identity.IrcIdent = SlId.ToString();
            identity.IrcDomain = AGENTHOST;

            return identity;
        }
 public IntermediateMessage(MappedIdentity sender, MessageType messageType)
 {
     this.Sender = sender;
     this.Type = messageType;
 }
 internal static IntermediateMessage ClientNotice(MappedIdentity sender, string payload)
 {
     var msg = new IntermediateMessage(sender, MessageType.ClientNotice);
     msg.Payload = payload;
     return msg;
 }
        public MappedIdentity MapObject(OpenMetaverse.UUID SlId, string SlName)
        {
            var identity = new MappedIdentity(IdentityCategory.Object);
            identity.SlName = SlName;
            identity.AvatarID = SlId;
            identity.IrcNick = MakeIrcName(SlName, ".");
            identity.IrcIdent = "object";
            identity.IrcDomain = OBJECTHOST;

            return identity;
        }
        public Task<MappedIdentity> MapObject(UUID slId, string SlName)
        {
            var identity = new MappedIdentity(IdentityCategory.Object);
            identity.SlName = SlName ?? "Object";
            identity.AvatarID = slId;
            identity.IrcNick = String.Join(".", SlName.Split(' ')); ;
            identity.IrcIdent = slId.ToString();
            identity.IrcDomain = "object." + gridDomain;

            return Task.FromResult(identity);
        }
 public MappedIdentity MapUser(MappedIdentity Identity)
 {
     return Identity;
 }