public RegionHandshakeData(RegionHandshake msg)
{
RegionFlags = msg.RegionFlags;
SimAccess = msg.SimAccess;
SimName = msg.SimName;
IsEstateManager = msg.IsEstateManager;
WaterHeight = msg.WaterHeight;
BillableFactor = msg.BillableFactor;
CacheID = msg.CacheID;
TerrainBase0 = msg.TerrainBase0;
TerrainBase1 = msg.TerrainBase1;
TerrainBase2 = msg.TerrainBase2;
TerrainBase3 = msg.TerrainBase3;
TerrainDetail0 = msg.TerrainDetail0;
TerrainDetail1 = msg.TerrainDetail1;
TerrainDetail2 = msg.TerrainDetail2;
TerrainDetail3 = msg.TerrainDetail3;
TerrainHeightRange00 = msg.TerrainHeightRange00;
TerrainHeightRange01 = msg.TerrainHeightRange01;
TerrainHeightRange10 = msg.TerrainHeightRange10;
TerrainHeightRange11 = msg.TerrainHeightRange11;
TerrainStartHeight00 = msg.TerrainStartHeight00;
TerrainStartHeight01 = msg.TerrainStartHeight01;
TerrainStartHeight10 = msg.TerrainStartHeight10;
TerrainStartHeight11 = msg.TerrainStartHeight11;
RegionID = msg.RegionID;
CPUClassID = msg.CPUClassID;
CPURatio = msg.CPURatio;
ColoName = msg.ColoName;
ProductSKU = msg.ProductSKU;
ProductName = msg.ProductName;
RegionExtData = msg.RegionExtData;
}
public override void SendRegionInfo(IAgent agent)
{
EstateInfo estateInfo;
lock (m_EstateDataUpdateLock)
{
estateInfo = m_EstateData;
}
estateInfo.Flags &= ~RegionOptionFlags.SunFixed;
RegionOptionFlags regionFlags = RegionSettings.AsFlags;
var res = new Viewer.Messages.Region.RegionInfo
{
AgentID = agent.Owner.ID,
SessionID = agent.Session.SessionID,
EstateID = estateInfo.ID,
ParentEstateID = estateInfo.ParentEstateID,
BillableFactor = estateInfo.BillableFactor,
PricePerMeter = estateInfo.PricePerMeter,
SimName = Name,
RegionFlags = regionFlags,
SimAccess = Access,
MaxAgents = (uint)RegionSettings.AgentLimit,
ObjectBonusFactor = RegionSettings.ObjectBonus,
WaterHeight = RegionSettings.WaterHeight,
TerrainRaiseLimit = RegionSettings.TerrainRaiseLimit,
TerrainLowerLimit = RegionSettings.TerrainLowerLimit,
RedirectGridX = 0,
RedirectGridY = 0,
UseEstateSun = RegionSettings.UseEstateSun,
ProductSKU = VersionInfo.SimulatorVersion,
ProductName = ProductName
};
if (RegionSettings.IsSunFixed)
{
res.RegionFlags |= RegionOptionFlags.SunFixed;
res.SunHour = RegionSettings.SunPosition + 6;
}
else
{
res.SunHour = 0;
}
res.RegionFlagsExtended.Add((ulong)regionFlags);
agent.SendMessageAlways(res, ID);
}
public EstateInfo(EstateInfo src)
{
ID = src.ID;
ParentEstateID = src.ParentEstateID;
Name = src.Name;
Flags = src.Flags;
Owner = new UGUI(src.Owner);
PricePerMeter = src.PricePerMeter;
BillableFactor = src.BillableFactor;
SunPosition = src.SunPosition;
AbuseEmail = src.AbuseEmail;
UseGlobalTime = src.UseGlobalTime;
CovenantID = src.CovenantID;
CovenantTimestamp = new Date(src.CovenantTimestamp);
}
protected override void SendSimStats(int dt)
{
int packetsReceived = m_PacketsReceived - m_LastPacketsReceived;
int packetsSent = m_PacketsSent - m_LastPacketsSent;
int agentUpdatesReceived = m_AgentUpdatesReceived - m_LastAgentUpdatesReceived;
int activeUploads = 0;
var agent = Agent;
var scene = Scene;
if (agent != null)
{
activeUploads += agent.m_TerrainTransactions.Count + agent.m_AssetTransactions.Count;
}
foreach (var cap in m_UploadCapabilities)
{
activeUploads += cap.ActiveUploads;
}
m_LastPacketsSent = m_PacketsSent;
m_LastPacketsReceived = m_PacketsReceived;
m_LastAgentUpdatesReceived = m_AgentUpdatesReceived;
m_SimStatsData[(int)SimStatIndex.InPacketsPerSecond].StatValue = (double)packetsReceived * 1000f / dt;
m_SimStatsData[(int)SimStatIndex.OutPacketsPerSecond].StatValue = (double)packetsSent * 1000f / dt;
m_SimStatsData[(int)SimStatIndex.PendingDownloads].StatValue = agent != null ?
m_TextureDownloadQueue.Count + m_InventoryRequestQueue.Count + agent.m_DownloadTransfersByName.Count :
m_TextureDownloadQueue.Count + m_InventoryRequestQueue.Count;
m_SimStatsData[(int)SimStatIndex.PendingUploads].StatValue = activeUploads;
m_SimStatsData[(int)SimStatIndex.AgentUpdates].StatValue = (double)agentUpdatesReceived * 1000f / dt;
m_SimStatsData[(int)SimStatIndex.UnAckedBytes].StatValue = m_UnackedBytes;
if (scene != null)
{
int rootAgents = scene.RootAgents.Count;
int childAgents = scene.Agents.Count - rootAgents;
if (childAgents < 0)
{
childAgents = 0;
}
m_SimStatsData[(int)SimStatIndex.Agents].StatValue = rootAgents;
m_SimStatsData[(int)SimStatIndex.ChildAgents].StatValue = childAgents;
m_SimStatsData[(int)SimStatIndex.TotalPrim].StatValue = scene.Primitives.Count;
m_SimStatsData[(int)SimStatIndex.ActivePrim].StatValue = scene.ActiveObjects;
int activeScripts = scene.ActiveScripts;
m_SimStatsData[(int)SimStatIndex.ActiveScripts].StatValue = scene.ScriptedObjects;
m_SimStatsData[(int)SimStatIndex.SimFPS].StatValue = scene.Environment.EnvironmentFps;
m_SimStatsData[(int)SimStatIndex.ScriptsTimeMs].StatValue = scene.ScriptThreadPool.ScriptTimeMsPerSec;
m_SimStatsData[(int)SimStatIndex.ScriptEventsPerSeconds].StatValue = scene.ScriptThreadPool.ScriptEventsPerSec;
if (activeScripts == 0)
{
m_SimStatsData[(int)SimStatIndex.PercentExecutingScripts].StatValue = 0;
}
else
{
m_SimStatsData[(int)SimStatIndex.PercentExecutingScripts].StatValue = 100.0 * scene.ScriptThreadPool.ExecutingScripts / activeScripts;
}
var physics = scene.PhysicsScene;
if (physics != null)
{
m_SimStatsData[(int)SimStatIndex.PhysicsFPS].StatValue = physics.PhysicsFPS;
m_SimStatsData[(int)SimStatIndex.PhysicsTimeMs].StatValue = physics.PhysicsExecutionTime * 1000f;
}
}
var stats = new SimStats();
if (scene != null)
{
stats.RegionX = scene.GridPosition.X;
stats.RegionY = scene.GridPosition.Y;
RegionOptionFlags regionFlags = scene.RegionSettings.AsFlags;
stats.RegionFlags = (uint)regionFlags;
stats.RegionFlagsExtended.Add((ulong)regionFlags);
}
stats.ObjectCapacity = 15000;
stats.PID = 0;
stats.Stat = m_SimStatsData;
SendMessage(stats);
CheckExperienceTimeouts();
}
private void UdpReceiveEndHandler(IAsyncResult ar)
{
Circuit circuit;
var pck = (UDPReceivePacket)ar.AsyncState;
try
{
pck.DataLength = m_UdpSocket.EndReceiveFrom(ar, ref pck.RemoteEndPoint);
}
catch
{
return;
}
finally
{
if (m_InboundRunning)
{
BeginUdpReceive();
}
}
pck.TransferredAtTime = Environment.TickCount;
pck.EnqueuedAtTime = Environment.TickCount;
/* we do not want to spend time on decoding packets that are unknown where they belong */
if (!m_Circuits.TryGetValue(pck.RemoteEndPoint, out circuit) || circuit.ForceUseCircuitCode)
{
try
{
/* check whether we got an UseCircuitCode */
var mType = pck.ReadMessageType();
if (MessageType.UseCircuitCode == mType)
{
var circuitcode = pck.ReadUInt32();
/* it is, so we have actually to look for the circuitcode and set up the remote endpoint here */
lock (m_UseCircuitCodeProcessingLock)
{
if (m_Circuits.TryGetValue(circuitcode, out circuit))
{
circuit.ForceUseCircuitCode = false;
var sessionID = pck.ReadUUID();
var agentID = pck.ReadUUID();
var acircuit = circuit as AgentCircuit;
if (acircuit != null)
{
/* there it is check for SessionID and AgentID */
if (!acircuit.SessionID.Equals(sessionID) ||
!acircuit.AgentID.Equals(agentID) ||
!VerifyEndpointAddress(acircuit, pck.RemoteEndPoint))
{
/* no match on SessionID or AgentID */
m_Log.DebugFormat("Unmatched UseCircuitCode for AgentID {0} SessionID {1} CircuitCode {2} received", agentID, sessionID, circuitcode);
}
else
{
/* it matches, so we have to change the actual key */
var endpoint = new IPEndPoint(0, 0);
var ep = endpoint.Create(pck.RemoteEndPoint.Serialize());
m_Circuits.Remove(circuit.CircuitCode);
m_Circuits.Add(ep, circuit.CircuitCode, circuit);
circuit.RemoteEndPoint = ep;
try
{
circuit.Start();
var scene = Scene;
RegionOptionFlags regionFlags = scene.RegionSettings.AsFlags;
var rh = new RegionHandshake
{
RegionFlags = regionFlags,
SimAccess = scene.Access,
SimName = scene.Name,
SimOwner = scene.Owner.ID,
IsEstateManager = scene.IsEstateManager(acircuit.Agent.Owner),
WaterHeight = scene.RegionSettings.WaterHeight,
BillableFactor = 1,
TerrainStartHeight00 = scene.RegionSettings.Elevation1SW,
TerrainStartHeight01 = scene.RegionSettings.Elevation2SW,
TerrainStartHeight10 = scene.RegionSettings.Elevation1NW,
TerrainStartHeight11 = scene.RegionSettings.Elevation2NW,
TerrainHeightRange00 = scene.RegionSettings.Elevation1SE,
TerrainHeightRange01 = scene.RegionSettings.Elevation2SE,
TerrainHeightRange10 = scene.RegionSettings.Elevation1NE,
TerrainHeightRange11 = scene.RegionSettings.Elevation2NE,
TerrainBase0 = UUID.Zero,
TerrainBase1 = UUID.Zero,
TerrainBase2 = UUID.Zero,
TerrainBase3 = UUID.Zero,
TerrainDetail0 = scene.RegionSettings.TerrainTexture1,
TerrainDetail1 = scene.RegionSettings.TerrainTexture2,
TerrainDetail2 = scene.RegionSettings.TerrainTexture3,
TerrainDetail3 = scene.RegionSettings.TerrainTexture4,
RegionID = scene.ID,
CacheID = UUID.Random,
CPUClassID = 9,
CPURatio = 1,
ColoName = string.Empty,
ProductSKU = VersionInfo.SimulatorVersion,
ProductName = scene.ProductName
};
rh.RegionExtData.Add(new RegionHandshake.RegionExtDataEntry
{
RegionFlagsExtended = (ulong)regionFlags,
RegionProtocols = RegionProtocolFlags.AgentAppearanceService
});
/* Immediate Ack */
circuit.SendCircuitPacket(UDPPacket.PacketAckImmediate(pck.SequenceNumber));
circuit.SendMessage(rh);
return;
}
catch (Exception e)
{
m_Log.DebugFormat("UseCircuitCode Exception {0} {1}\n{2}", e.GetType().Name, e.Message, e.StackTrace);
circuit.Stop();
}
}
}
}
else
{
m_Log.DebugFormat("UseCircuitCode received for unknown circuit {0}", circuitcode);
}
}
}
else if (MessageType.NetTest == mType && (uint)m_NetTestSeqNumber == pck.SequenceNumber ||
pck.ReadUInt16() == (ushort)LocalPort)
{
OnNetTest?.Invoke(((IPEndPoint)pck.RemoteEndPoint).Address, LocalPort);
return;
}
#if DEBUG
if (mType != MessageType.StartPingCheck)
{
/* do not show that message for a StartPingCheck */
m_Log.DebugFormat("Unmatched endpoint address {0} for UDP server at port {1}", pck.RemoteEndPoint.ToString(), LocalPort);
}
#endif
}
catch
{
/* no action required */
}
return;
}
/* here we spend time on decoding */
if (pck.IsUndersized)
{
/* packet is undersized so we throw it away as well */
return;
}
/* now we know that the packet is at least valid
* We can pass it to the circuit handler.
*/
/* we decode the ack numbers here, the code does not need to be implemented in the UDP Circuit Handler */
List <UInt32> acknumbers = null;
if (pck.HasAckFlag)
{
try
{
acknumbers = pck.Acks;
}
catch
{
/* packet is undersized so we throw it away as well */
return;
}
}
try
{
circuit.PacketReceived(pck.RemoteEndPoint, pck, acknumbers);
}
catch (Exception e)
{
/* we catch all issues here */
m_Log.ErrorFormat("Exception {0} => {1} at {2}", e.GetType().Name, e.ToString(), e.StackTrace);
}
/* return the buffer to the pool */
}
