void UUIDNameRequestHandler(Packet packet, Agent agent)
{
UUIDNameRequestPacket request = (UUIDNameRequestPacket)packet;
UUIDNameReplyPacket reply = new UUIDNameReplyPacket();
reply.UUIDNameBlock = new UUIDNameReplyPacket.UUIDNameBlockBlock[request.UUIDNameBlock.Length];
for (int i = 0; i < request.UUIDNameBlock.Length; i++)
{
UUID id = request.UUIDNameBlock[i].ID;
reply.UUIDNameBlock[i] = new UUIDNameReplyPacket.UUIDNameBlockBlock();
reply.UUIDNameBlock[i].ID = id;
Agent foundAgent;
if (server.Agents.TryGetValue(id, out foundAgent))
{
reply.UUIDNameBlock[i].FirstName = Utils.StringToBytes(foundAgent.FirstName);
reply.UUIDNameBlock[i].LastName = Utils.StringToBytes(foundAgent.LastName);
}
else
{
reply.UUIDNameBlock[i].FirstName = new byte[0];
reply.UUIDNameBlock[i].LastName = new byte[0];
}
}
server.UDP.SendPacket(agent.AgentID, reply, PacketCategory.Transaction);
}
/// <summary>
/// Process an incoming UUIDNameReply Packet and insert Full Names into the Avatars Dictionary
/// </summary>
/// <param name="packet">Incoming Packet to process</param>
/// <param name="simulator">Unused</param>
private void GetAgentNameHandler(Packet packet, Simulator simulator)
{
Dictionary <LLUUID, string> names = new Dictionary <LLUUID, string>();
UUIDNameReplyPacket reply = (UUIDNameReplyPacket)packet;
lock (Avatars)
{
foreach (UUIDNameReplyPacket.UUIDNameBlockBlock block in reply.UUIDNameBlock)
{
if (!Avatars.ContainsKey(block.ID))
{
Avatars[block.ID] = new Avatar();
Avatars[block.ID].ID = block.ID;
}
Avatars[block.ID].Name = Helpers.FieldToString(block.FirstName) +
" " + Helpers.FieldToString(block.LastName);
names[block.ID] = Avatars[block.ID].Name;
}
}
if (OnAgentNames != null)
{
OnAgentNames(names);
}
}
private Packet GotName(Packet p, IPEndPoint sim)
{
UUIDNameReplyPacket n = (UUIDNameReplyPacket)p;
lock (shared.key2name)
{
lock (shared.name2key)
{
foreach (UUIDNameReplyPacket.UUIDNameBlockBlock b in n.UUIDNameBlock)
{
if (!shared.key2name.ContainsKey(b.ID))
{
string name = Utils.BytesToString(b.FirstName) + " " + Utils.BytesToString(b.LastName);
shared.key2name.Add(b.ID, name);
if (!shared.name2key.ContainsKey(name))
{
shared.name2key.Add(name, b.ID);
}
}
lock (pending)
{
if (pending.Contains(b.ID))
{
pending.Remove(b.ID);
frame.SayToUser(shared.key2name[b.ID] + " = " + b.ID.ToString());
}
}
}
}
}
return(p);
}
/// <summary>
/// Process an incoming UUIDNameReply Packet and insert Full Names into the Avatars Dictionary
/// </summary>
/// <param name="packet">Incoming Packet to process</param>
/// <param name="simulator">Unused</param>
private void AvatarNameHandler(Packet packet, Simulator simulator)
{
if (OnAvatarNames != null)
{
Dictionary <LLUUID, string> names = new Dictionary <LLUUID, string>();
UUIDNameReplyPacket reply = (UUIDNameReplyPacket)packet;
foreach (UUIDNameReplyPacket.UUIDNameBlockBlock block in reply.UUIDNameBlock)
{
names[block.ID] = Helpers.FieldToUTF8String(block.FirstName) +
" " + Helpers.FieldToUTF8String(block.LastName);
}
OnAvatarNames(names);
}
}
private Packet OutAvatarPropertiesRequestHandler(Packet requestpacket, IPEndPoint sim)
{
if (requestpacket.Header.Resent)
{
return(requestpacket);
}
AvatarPropertiesRequestPacket packet = (AvatarPropertiesRequestPacket)requestpacket;
UUID uuid = packet.AgentData.AvatarID;
System.Timers.Timer timer = new System.Timers.Timer(5000);
bool found = false;
PacketDelegate replyCallback = delegate(Packet replypacket, IPEndPoint blarg)
{
if (!found)
{
UUIDNameReplyPacket reply = (UUIDNameReplyPacket)replypacket;
foreach (UUIDNameReplyPacket.UUIDNameBlockBlock block in reply.UUIDNameBlock)
{
if (block.ID == uuid)
{
found = true;
string firstname = Utils.BytesToString(block.FirstName);
string lastname = Utils.BytesToString(block.LastName);
frame.SayToUser(firstname + " " + lastname + " = " + uuid.ToString());
return(replypacket);
}
}
}
return(replypacket);
};
proxy.AddDelegate(PacketType.UUIDNameReply, Direction.Incoming, replyCallback);
timer.Elapsed += delegate(object sender, System.Timers.ElapsedEventArgs e)
{
proxy.RemoveDelegate(PacketType.UUIDNameReply, Direction.Incoming, replyCallback);
timer.Stop();
};
UUIDNameRequestPacket request = new UUIDNameRequestPacket();
request.UUIDNameBlock = new UUIDNameRequestPacket.UUIDNameBlockBlock[1];
request.UUIDNameBlock[0] = new UUIDNameRequestPacket.UUIDNameBlockBlock();
request.UUIDNameBlock[0].ID = uuid;
request.Header.Reliable = true;
proxy.InjectPacket(request, Direction.Outgoing);
timer.Start();
return(packet);
}
private void UUIDNameRequestHandler(Packet packet, LLAgent agent)
{
UUIDNameRequestPacket request = (UUIDNameRequestPacket)packet;
List <UUIDNameReplyPacket.UUIDNameBlockBlock> responses = new List <UUIDNameReplyPacket.UUIDNameBlockBlock>();
for (int i = 0; i < request.UUIDNameBlock.Length; i++)
{
UUID requestID = request.UUIDNameBlock[i].ID;
string firstName = null, lastName = null;
// See if we can fetch a presence in the local scene with the requested UUID first
IScenePresence localPresence;
if (m_scene.TryGetPresence(requestID, out localPresence))
{
Util.GetFirstLastName(localPresence.Name, out firstName, out lastName);
}
else if (m_userClient != null)
{
// TODO: We might want to switch to a batch user service command in the future
User user;
if (m_userClient.TryGetUser(requestID, out user))
{
Util.GetFirstLastName(user.Name, out firstName, out lastName);
}
}
if (firstName != null && lastName != null)
{
UUIDNameReplyPacket.UUIDNameBlockBlock block = new UUIDNameReplyPacket.UUIDNameBlockBlock();
block.ID = requestID;
block.FirstName = Utils.StringToBytes(firstName);
block.LastName = Utils.StringToBytes(lastName);
responses.Add(block);
}
}
// Build the response packet
UUIDNameReplyPacket response = new UUIDNameReplyPacket();
response.UUIDNameBlock = responses.ToArray();
m_udp.SendPacket(agent, response, ThrottleCategory.Task, true);
}
public bool RequestUUIDName(SimClient simClient, Packet packet)
{
System.Text.Encoding enc = System.Text.Encoding.ASCII;
Console.WriteLine(packet.ToString());
UUIDNameRequestPacket nameRequest = (UUIDNameRequestPacket)packet;
UUIDNameReplyPacket nameReply = new UUIDNameReplyPacket();
nameReply.UUIDNameBlock = new UUIDNameReplyPacket.UUIDNameBlockBlock[nameRequest.UUIDNameBlock.Length];
for (int i = 0; i < nameRequest.UUIDNameBlock.Length; i++)
{
nameReply.UUIDNameBlock[i] = new UUIDNameReplyPacket.UUIDNameBlockBlock();
nameReply.UUIDNameBlock[i].ID = nameRequest.UUIDNameBlock[i].ID;
nameReply.UUIDNameBlock[i].FirstName = enc.GetBytes("Who\0"); //for now send any name
nameReply.UUIDNameBlock[i].LastName = enc.GetBytes("Knows\0"); //in future need to look it up
}
simClient.OutPacket(nameReply);
return true;
}
public bool RequestUUIDName(SimClient simClient, Packet packet)
{
System.Text.Encoding enc = System.Text.Encoding.ASCII;
Console.WriteLine(packet.ToString());
UUIDNameRequestPacket nameRequest = (UUIDNameRequestPacket)packet;
UUIDNameReplyPacket nameReply = new UUIDNameReplyPacket();
nameReply.UUIDNameBlock = new UUIDNameReplyPacket.UUIDNameBlockBlock[nameRequest.UUIDNameBlock.Length];
for (int i = 0; i < nameRequest.UUIDNameBlock.Length; i++)
{
nameReply.UUIDNameBlock[i] = new UUIDNameReplyPacket.UUIDNameBlockBlock();
nameReply.UUIDNameBlock[i].ID = nameRequest.UUIDNameBlock[i].ID;
nameReply.UUIDNameBlock[i].FirstName = enc.GetBytes("Who\0"); //for now send any name
nameReply.UUIDNameBlock[i].LastName = enc.GetBytes("Knows\0"); //in future need to look it up
}
simClient.OutPacket(nameReply);
return(true);
}
public Packet GotTheirName(Packet packet, IPEndPoint sim)
{
if (currentBastard != UUID.Zero)
{
UUIDNameReplyPacket nr = (UUIDNameReplyPacket)packet;
for (int i = 0; i < nr.UUIDNameBlock.Length; i++)
{
if (nr.UUIDNameBlock[i].ID == currentBastard)
{
string whatsup = Utils.BytesToString(nr.UUIDNameBlock[i].FirstName) + " " + Utils.BytesToString(nr.UUIDNameBlock[i].LastName) + " has just removed you from their freinds list!\n" +
"This was at " + System.DateTime.Now.ToShortDateString() + " : " + System.DateTime.Now.ToShortTimeString();
frame.SayToUser(whatsup);
frame.SendUserAlert(whatsup);
frame.SendUserDialog("Freindship", "Over", "Alert!", whatsup, new String[] { "DAMN!" });
}
}
}
return(packet);
}
private void UUIDNameRequestHandler(Packet packet, LLAgent agent)
{
UUIDNameRequestPacket request = (UUIDNameRequestPacket)packet;
List<UUIDNameReplyPacket.UUIDNameBlockBlock> responses = new List<UUIDNameReplyPacket.UUIDNameBlockBlock>();
for (int i = 0; i < request.UUIDNameBlock.Length; i++)
{
UUID requestID = request.UUIDNameBlock[i].ID;
string firstName = null, lastName = null;
// See if we can fetch a presence in the local scene with the requested UUID first
IScenePresence localPresence;
if (m_scene.TryGetPresence(requestID, out localPresence))
{
Util.GetFirstLastName(localPresence.Name, out firstName, out lastName);
}
else if (m_userClient != null)
{
// TODO: We might want to switch to a batch user service command in the future
User user;
if (m_userClient.TryGetUser(requestID, out user))
Util.GetFirstLastName(user.Name, out firstName, out lastName);
}
if (firstName != null && lastName != null)
{
UUIDNameReplyPacket.UUIDNameBlockBlock block = new UUIDNameReplyPacket.UUIDNameBlockBlock();
block.ID = requestID;
block.FirstName = Utils.StringToBytes(firstName);
block.LastName = Utils.StringToBytes(lastName);
responses.Add(block);
}
}
// Build the response packet
UUIDNameReplyPacket response = new UUIDNameReplyPacket();
response.UUIDNameBlock = responses.ToArray();
m_udp.SendPacket(agent, response, ThrottleCategory.Task, true);
}
public Packet IMs(Packet p, IPEndPoint sim)
{
if (enabled)
{
GregIm g = new GregIm();
ImprovedInstantMessagePacket imm = (ImprovedInstantMessagePacket)p;
g.fromname = Utils.BytesToString(imm.MessageBlock.FromAgentName);
g.ownerkey = imm.AgentData.AgentID;
g.regionkey = imm.MessageBlock.RegionID;
g.regionpos = imm.MessageBlock.Position;
bool debug = false;
bool mapFound;
bool regionFound;
bool nameFound;
mapFound = regionFound = nameFound = false;
if (g.regionkey != UUID.Zero && imm.MessageBlock.Dialog == (byte)InstantMessageDialog.MessageFromObject)
{
/*if ((imm.MessageBlock.Dialog == 0 && imm.MessageBlock.Offline != 1) || g.ownerkey == frame.AgentID)
* {
* imm.MessageBlock.FromAgentName = Utils.StringToBytes(g.fromname.ToString() + " @ " + g.regionpos.ToString());
* return imm;
* }*/
g.p = imm;
if (debug)
{
frame.SayToUser("region key was not zero..:");
}
// request region name
RegionHandleRequestPacket rhp = new RegionHandleRequestPacket();
rhp.RequestBlock.RegionID = g.regionkey;
System.Timers.Timer mygregTimer = new System.Timers.Timer(30000);
PacketDelegate replyGregCallback = delegate(Packet pa, IPEndPoint s)
{
if (debug)
{
frame.SayToUser("got the region handle...");
}
if (!regionFound)
{
regionFound = true;
RegionIDAndHandleReplyPacket rid = (RegionIDAndHandleReplyPacket)pa;
ulong handle = rid.ReplyBlock.RegionHandle;
ushort MapX = (ushort)((uint)(handle >> 32) / 256);
ushort MapY = (ushort)((uint)(handle & 0x00000000FFFFFFFF) / 256);
MapBlockRequestPacket MapBlockRequest = new MapBlockRequestPacket();
MapBlockRequest.AgentData = new MapBlockRequestPacket.AgentDataBlock();
MapBlockRequest.AgentData.AgentID = frame.AgentID;
MapBlockRequest.AgentData.SessionID = frame.SessionID;
MapBlockRequest.AgentData.Flags = 0;
MapBlockRequest.AgentData.Godlike = false;
MapBlockRequest.PositionData = new MapBlockRequestPacket.PositionDataBlock();
MapBlockRequest.PositionData.MinX = MapX;
MapBlockRequest.PositionData.MaxX = MapX;
MapBlockRequest.PositionData.MinY = MapY;
MapBlockRequest.PositionData.MaxY = MapY;
System.Timers.Timer myTimer2 = new System.Timers.Timer(20000);
PacketDelegate replyCallback = delegate(Packet np, IPEndPoint ss)
{
if (debug)
{
frame.SayToUser("got the map..:");
}
if (!mapFound)
{
mapFound = true;
MapBlockReplyPacket reply = (MapBlockReplyPacket)np;
foreach (MapBlockReplyPacket.DataBlock block in reply.Data)
{
if ((block.X == MapX) && (block.Y == MapY))
{
g.regionName = Utils.BytesToString(block.Name);
g.regionglobalx = MapX;
g.regionglobaly = MapY;
g.slurl = "secondlife://" + g.regionName.Replace(" ", "%20") + "/" + g.regionpos.X.ToString() + "/" + g.regionpos.Y.ToString() + "/" + g.regionpos.Z.ToString();
System.Timers.Timer timer = new System.Timers.Timer(10000);
PacketDelegate replyCallback2 = delegate(Packet replypacket, IPEndPoint blarg)
{
if (debug)
{
frame.SayToUser("got the name");
}
UUIDNameReplyPacket ureply = (UUIDNameReplyPacket)replypacket;
foreach (UUIDNameReplyPacket.UUIDNameBlockBlock bblock in ureply.UUIDNameBlock)
{
if (bblock.ID == g.ownerkey)
{
if (!nameFound)
{
nameFound = true;
string firstname = Utils.BytesToString(bblock.FirstName);
string lastname = Utils.BytesToString(bblock.LastName);
g.ownername = firstname + " " + lastname;
g.p.MessageBlock.FromAgentName = Utils.StringToBytes(g.ownername + "'s " + g.fromname + " @ " + g.slurl);
form.addListItem(g.ownerkey.ToString() + " \t" + g.ownername + " \t" + g.slurl + " \t" + g.fromname + " \t" + Utils.BytesToString(g.p.MessageBlock.Message));
imm = g.p;
proxy.InjectPacket(g.p, Direction.Incoming);
}
return(replypacket);
}
}
return(replypacket);
};
proxy.AddDelegate(PacketType.UUIDNameReply, Direction.Incoming, replyCallback2);
timer.Elapsed += delegate(object sender, System.Timers.ElapsedEventArgs e)
{
proxy.RemoveDelegate(PacketType.UUIDNameReply, Direction.Incoming, replyCallback2);
timer.Stop();
//proxy.InjectPacket(p, Direction.Incoming);
};
UUIDNameRequestPacket request = new UUIDNameRequestPacket();
request.UUIDNameBlock = new UUIDNameRequestPacket.UUIDNameBlockBlock[1];
request.UUIDNameBlock[0] = new UUIDNameRequestPacket.UUIDNameBlockBlock();
request.UUIDNameBlock[0].ID = g.ownerkey;
request.Header.Reliable = true;
proxy.InjectPacket(request, Direction.Outgoing);
timer.Start();
}
}
}
return(np);
};
System.Timers.ElapsedEventHandler timerCallback = delegate(object sender, System.Timers.ElapsedEventArgs e)
{
proxy.RemoveDelegate(PacketType.MapBlockReply, Direction.Incoming, replyCallback);
myTimer2.Stop();
//proxy.InjectPacket(p, Direction.Incoming);
};
proxy.AddDelegate(PacketType.MapBlockReply, Direction.Incoming, replyCallback);
myTimer2.Elapsed += timerCallback;
myTimer2.Start();
proxy.InjectPacket(MapBlockRequest, Direction.Outgoing);
}
return(pa);
};
System.Timers.ElapsedEventHandler timerGregCallback = delegate(object sender, System.Timers.ElapsedEventArgs e)
{
proxy.RemoveDelegate(PacketType.RegionIDAndHandleReply, Direction.Incoming, replyGregCallback);
mygregTimer.Stop();
//proxy.InjectPacket(p, Direction.Incoming);
};
proxy.AddDelegate(PacketType.RegionIDAndHandleReply, Direction.Incoming, replyGregCallback);
mygregTimer.Elapsed += timerGregCallback;
mygregTimer.Start();
proxy.InjectPacket(rhp, Direction.Outgoing);
//----------------------
return(null);
}
}
return(p);
}
