mirror of
https://github.com/opensim/opensim.git
synced 2026-07-20 14:45:38 +08:00
62bcf0e694
Don't allow packets to be resent before they have actually been sent for the first time. Switch from serializing a packet to get it's length to the LibOMV provided Length property. Fix resend timing. Fix the use of dangling references to Acked packets. Fix the packet handler to play nice with the packet pool. Fix the packet pool. Add data block recycling to the packet pool. Packet pool is now ENABLED by default. Add config option to disable packet and data block reuse. Add ObjectUpdate and ImprovedTerseObjectUpdate to the packets being recycled.
812 lines
27 KiB
C#
812 lines
27 KiB
C#
/*
|
|
* Copyright (c) Contributors, http://opensimulator.org/
|
|
* See CONTRIBUTORS.TXT for a full list of copyright holders.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* * Neither the name of the OpenSim Project nor the
|
|
* names of its contributors may be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
|
|
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Net.Sockets;
|
|
using System.Threading;
|
|
using System.Timers;
|
|
using OpenMetaverse;
|
|
using OpenMetaverse.Packets;
|
|
using OpenSim.Framework;
|
|
using Timer=System.Timers.Timer;
|
|
|
|
namespace OpenSim.Region.ClientStack.LindenUDP
|
|
{
|
|
public class LLPacketHandler : ILLPacketHandler
|
|
{
|
|
//private static readonly ILog m_log
|
|
// = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
|
|
|
|
//private int m_resentCount;
|
|
|
|
// Packet queues
|
|
//
|
|
LLPacketQueue m_PacketQueue;
|
|
|
|
public LLPacketQueue PacketQueue
|
|
{
|
|
get { return m_PacketQueue; }
|
|
}
|
|
|
|
// Timer to run stats and acks on
|
|
//
|
|
private Timer m_AckTimer = new Timer(250);
|
|
|
|
// A list of the packets we haven't acked yet
|
|
//
|
|
private Dictionary<uint, uint> m_PendingAcks = new Dictionary<uint, uint>();
|
|
|
|
private Dictionary<uint, LLQueItem> m_NeedAck =
|
|
new Dictionary<uint, LLQueItem>();
|
|
|
|
/// <summary>
|
|
/// The number of milliseconds that can pass before a packet that needs an ack is resent.
|
|
/// </param>
|
|
private uint m_ResendTimeout = 4000;
|
|
|
|
public uint ResendTimeout
|
|
{
|
|
get { return m_ResendTimeout; }
|
|
set { m_ResendTimeout = value; }
|
|
}
|
|
|
|
private int m_MaxReliableResends = 3;
|
|
|
|
public int MaxReliableResends
|
|
{
|
|
get { return m_MaxReliableResends; }
|
|
set { m_MaxReliableResends = value; }
|
|
}
|
|
|
|
// Track duplicated packets. This uses a Dictionary. Both insertion
|
|
// and lookup are common operations and need to take advantage of
|
|
// the hashing. Expiration is less common and can be allowed the
|
|
// time for a linear scan.
|
|
//
|
|
private Dictionary<uint, int> m_DupeTracker =
|
|
new Dictionary<uint, int>();
|
|
private uint m_DupeTrackerWindow = 30;
|
|
private int m_DupeTrackerLastCheck = Environment.TickCount;
|
|
|
|
// Values for the SimStatsReporter
|
|
//
|
|
private int m_PacketsReceived = 0;
|
|
private int m_PacketsReceivedReported = 0;
|
|
private int m_PacketsSent = 0;
|
|
private int m_PacketsSentReported = 0;
|
|
private int m_UnackedBytes = 0;
|
|
|
|
private int m_LastResend = 0;
|
|
|
|
public int PacketsReceived
|
|
{
|
|
get { return m_PacketsReceived; }
|
|
}
|
|
|
|
public int PacketsReceivedReported
|
|
{
|
|
get { return m_PacketsReceivedReported; }
|
|
}
|
|
|
|
// The client we are working for
|
|
//
|
|
private IClientAPI m_Client;
|
|
|
|
// Some events
|
|
//
|
|
public event PacketStats OnPacketStats;
|
|
public event PacketDrop OnPacketDrop;
|
|
|
|
|
|
//private SynchronizeClientHandler m_SynchronizeClient = null;
|
|
|
|
public SynchronizeClientHandler SynchronizeClient
|
|
{
|
|
set { /* m_SynchronizeClient = value; */ }
|
|
}
|
|
|
|
// Packet sequencing
|
|
//
|
|
private uint m_Sequence = 0;
|
|
private object m_SequenceLock = new object();
|
|
private const int MAX_SEQUENCE = 0xFFFFFF;
|
|
|
|
// Packet dropping
|
|
//
|
|
List<PacketType> m_ImportantPackets = new List<PacketType>();
|
|
private bool m_ReliableIsImportant = false;
|
|
|
|
public bool ReliableIsImportant
|
|
{
|
|
get { return m_ReliableIsImportant; }
|
|
set { m_ReliableIsImportant = value; }
|
|
}
|
|
|
|
private int m_DropSafeTimeout;
|
|
|
|
LLPacketServer m_PacketServer;
|
|
private byte[] m_ZeroOutBuffer = new byte[4096];
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
|
|
// Constructors
|
|
//
|
|
public LLPacketHandler(IClientAPI client, LLPacketServer server, ClientStackUserSettings userSettings)
|
|
{
|
|
m_Client = client;
|
|
m_PacketServer = server;
|
|
m_DropSafeTimeout = Environment.TickCount + 15000;
|
|
|
|
m_PacketQueue = new LLPacketQueue(client.AgentId, userSettings);
|
|
|
|
m_AckTimer.Elapsed += AckTimerElapsed;
|
|
m_AckTimer.Start();
|
|
}
|
|
|
|
public void Stop()
|
|
{
|
|
m_AckTimer.Stop();
|
|
|
|
m_PacketQueue.Enqueue(null);
|
|
m_PacketQueue.Close();
|
|
m_Client = null;
|
|
}
|
|
|
|
// Send one packet. This actually doesn't send anything, it queues
|
|
// it. Designed to be fire-and-forget, but there is an optional
|
|
// notifier.
|
|
//
|
|
public void OutPacket(
|
|
Packet packet, ThrottleOutPacketType throttlePacketType)
|
|
{
|
|
OutPacket(packet, throttlePacketType, null);
|
|
}
|
|
|
|
public void OutPacket(
|
|
Packet packet, ThrottleOutPacketType throttlePacketType,
|
|
Object id)
|
|
{
|
|
// Call the load balancer's hook. If this is not active here
|
|
// we defer to the sim server this client is actually connected
|
|
// to. Packet drop notifies will not be triggered in this
|
|
// configuration!
|
|
//
|
|
|
|
packet.Header.Sequence = 0;
|
|
|
|
lock (m_NeedAck)
|
|
{
|
|
DropResend(id);
|
|
|
|
AddAcks(ref packet);
|
|
QueuePacket(packet, throttlePacketType, id);
|
|
}
|
|
}
|
|
|
|
private void AddAcks(ref Packet packet)
|
|
{
|
|
// These packet types have shown to have issues with
|
|
// acks being appended to the payload, just don't send
|
|
// any with them until libsl is fixed.
|
|
//
|
|
if (packet is ViewerEffectPacket)
|
|
return;
|
|
if (packet is SimStatsPacket)
|
|
return;
|
|
|
|
// Add acks to outgoing packets
|
|
//
|
|
if (m_PendingAcks.Count > 0)
|
|
{
|
|
int count = m_PendingAcks.Count;
|
|
if (count > 10)
|
|
count = 10;
|
|
packet.Header.AckList = new uint[count];
|
|
packet.Header.AppendedAcks = true;
|
|
|
|
int i = 0;
|
|
|
|
foreach (uint ack in new List<uint>(m_PendingAcks.Keys))
|
|
{
|
|
packet.Header.AckList[i] = ack;
|
|
i++;
|
|
m_PendingAcks.Remove(ack);
|
|
if (i >= count) // That is how much space there is
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void QueuePacket(
|
|
Packet packet, ThrottleOutPacketType throttlePacketType,
|
|
Object id)
|
|
{
|
|
LLQueItem item = new LLQueItem();
|
|
item.Packet = packet;
|
|
item.Incoming = false;
|
|
item.throttleType = throttlePacketType;
|
|
item.TickCount = Environment.TickCount;
|
|
item.Identifier = id;
|
|
item.Resends = 0;
|
|
item.Length = packet.Length;
|
|
item.Sequence = packet.Header.Sequence;
|
|
|
|
m_PacketQueue.Enqueue(item);
|
|
m_PacketsSent++;
|
|
}
|
|
|
|
private void ResendUnacked()
|
|
{
|
|
int now = Environment.TickCount;
|
|
|
|
int intervalMs = 250;
|
|
|
|
if (m_LastResend != 0)
|
|
intervalMs = now - m_LastResend;
|
|
|
|
lock (m_NeedAck)
|
|
{
|
|
if (m_DropSafeTimeout > now ||
|
|
intervalMs > 500) // We were frozen!
|
|
{
|
|
foreach (LLQueItem data in new List<LLQueItem>
|
|
(m_NeedAck.Values))
|
|
{
|
|
if (m_DropSafeTimeout > now)
|
|
{
|
|
m_NeedAck[data.Packet.Header.Sequence].
|
|
TickCount = now;
|
|
}
|
|
else
|
|
{
|
|
m_NeedAck[data.Packet.Header.Sequence].
|
|
TickCount += intervalMs;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
m_LastResend = now;
|
|
|
|
// Unless we have received at least one ack, don't bother resending
|
|
// anything. There may not be a client there, don't clog up the
|
|
// pipes.
|
|
//
|
|
lock (m_NeedAck)
|
|
{
|
|
// Nothing to do
|
|
//
|
|
if (m_NeedAck.Count == 0)
|
|
return;
|
|
|
|
int resent = 0;
|
|
|
|
foreach (LLQueItem data in new List<LLQueItem>(m_NeedAck.Values))
|
|
{
|
|
Packet packet = data.Packet;
|
|
|
|
// Packets this old get resent
|
|
//
|
|
if ((now - data.TickCount) > m_ResendTimeout && data.Sequence != 0)
|
|
{
|
|
if (resent < 20)
|
|
{
|
|
m_NeedAck[packet.Header.Sequence].Resends++;
|
|
|
|
// The client needs to be told that a packet is being resent, otherwise it appears to believe
|
|
// that it should reset its sequence to that packet number.
|
|
packet.Header.Resent = true;
|
|
|
|
if ((m_NeedAck[packet.Header.Sequence].Resends >=
|
|
m_MaxReliableResends) && (!m_ReliableIsImportant))
|
|
{
|
|
m_NeedAck.Remove(packet.Header.Sequence);
|
|
TriggerOnPacketDrop(packet, data.Identifier);
|
|
m_PacketQueue.Cancel(packet.Header.Sequence);
|
|
PacketPool.Instance.ReturnPacket(packet);
|
|
continue;
|
|
}
|
|
|
|
m_NeedAck[packet.Header.Sequence].TickCount =
|
|
Environment.TickCount;
|
|
|
|
QueuePacket(packet, ThrottleOutPacketType.Resend,
|
|
data.Identifier);
|
|
|
|
resent++;
|
|
}
|
|
else
|
|
{
|
|
m_NeedAck[packet.Header.Sequence].TickCount +=
|
|
intervalMs;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Send the pending packet acks to the client
|
|
// Will send blocks of acks for up to 250 packets
|
|
//
|
|
private void SendAcks()
|
|
{
|
|
lock (m_NeedAck)
|
|
{
|
|
if (m_PendingAcks.Count == 0)
|
|
return;
|
|
|
|
PacketAckPacket acks = (PacketAckPacket)PacketPool.Instance.GetPacket(PacketType.PacketAck);
|
|
|
|
// The case of equality is more common than one might think,
|
|
// because this function will be called unconditionally when
|
|
// the counter reaches 250. So there is a good chance another
|
|
// packet with 250 blocks exists.
|
|
//
|
|
if (acks.Packets == null ||
|
|
acks.Packets.Length != m_PendingAcks.Count)
|
|
acks.Packets = new PacketAckPacket.PacketsBlock[m_PendingAcks.Count];
|
|
int i = 0;
|
|
foreach (uint ack in new List<uint>(m_PendingAcks.Keys))
|
|
{
|
|
acks.Packets[i] = new PacketAckPacket.PacketsBlock();
|
|
acks.Packets[i].ID = ack;
|
|
|
|
m_PendingAcks.Remove(ack);
|
|
i++;
|
|
}
|
|
|
|
acks.Header.Reliable = false;
|
|
OutPacket(acks, ThrottleOutPacketType.Unknown);
|
|
}
|
|
}
|
|
|
|
// Queue a packet ack. It will be sent either after 250 acks are
|
|
// queued, or when the timer fires.
|
|
//
|
|
private void AckPacket(Packet packet)
|
|
{
|
|
lock (m_NeedAck)
|
|
{
|
|
if (m_PendingAcks.Count < 250)
|
|
{
|
|
if (!m_PendingAcks.ContainsKey(packet.Header.Sequence))
|
|
m_PendingAcks.Add(packet.Header.Sequence,
|
|
packet.Header.Sequence);
|
|
return;
|
|
}
|
|
}
|
|
|
|
SendAcks();
|
|
|
|
lock (m_NeedAck)
|
|
{
|
|
// If this is still full we have a truly exceptional
|
|
// condition (means, can't happen)
|
|
//
|
|
if (m_PendingAcks.Count < 250)
|
|
{
|
|
if (!m_PendingAcks.ContainsKey(packet.Header.Sequence))
|
|
m_PendingAcks.Add(packet.Header.Sequence,
|
|
packet.Header.Sequence);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// When the timer elapses, send the pending acks, trigger resends
|
|
// and report all the stats.
|
|
//
|
|
private void AckTimerElapsed(object sender, ElapsedEventArgs ea)
|
|
{
|
|
SendAcks();
|
|
ResendUnacked();
|
|
SendPacketStats();
|
|
}
|
|
|
|
// Push out pachet counts for the sim status reporter
|
|
//
|
|
private void SendPacketStats()
|
|
{
|
|
PacketStats handlerPacketStats = OnPacketStats;
|
|
if (handlerPacketStats != null)
|
|
{
|
|
handlerPacketStats(
|
|
m_PacketsReceived - m_PacketsReceivedReported,
|
|
m_PacketsSent - m_PacketsSentReported,
|
|
m_UnackedBytes);
|
|
|
|
m_PacketsReceivedReported = m_PacketsReceived;
|
|
m_PacketsSentReported = m_PacketsSent;
|
|
}
|
|
}
|
|
|
|
// We can't keep an unlimited record of dupes. This will prune the
|
|
// dictionary by age.
|
|
//
|
|
private void PruneDupeTracker()
|
|
{
|
|
lock (m_DupeTracker)
|
|
{
|
|
if (m_DupeTracker.Count < 1024)
|
|
return;
|
|
|
|
if (Environment.TickCount - m_DupeTrackerLastCheck < 2000)
|
|
return;
|
|
|
|
m_DupeTrackerLastCheck = Environment.TickCount;
|
|
|
|
Dictionary<uint, int> packs =
|
|
new Dictionary<uint, int>(m_DupeTracker);
|
|
|
|
foreach (uint pack in packs.Keys)
|
|
{
|
|
if (Util.UnixTimeSinceEpoch() - m_DupeTracker[pack] >
|
|
m_DupeTrackerWindow)
|
|
m_DupeTracker.Remove(pack);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void InPacket(Packet packet)
|
|
{
|
|
if (packet == null)
|
|
return;
|
|
|
|
// When too many acks are needed to be sent, the client sends
|
|
// a packet consisting of acks only
|
|
//
|
|
if (packet.Type == PacketType.PacketAck)
|
|
{
|
|
PacketAckPacket ackPacket = (PacketAckPacket)packet;
|
|
|
|
foreach (PacketAckPacket.PacketsBlock block in
|
|
ackPacket.Packets)
|
|
{
|
|
ProcessAck(block.ID);
|
|
}
|
|
|
|
PacketPool.Instance.ReturnPacket(packet);
|
|
return;
|
|
}
|
|
|
|
// Any packet can have some packet acks in the header.
|
|
// Process them here
|
|
//
|
|
if (packet.Header.AppendedAcks)
|
|
{
|
|
foreach (uint id in packet.Header.AckList)
|
|
{
|
|
ProcessAck(id);
|
|
}
|
|
}
|
|
|
|
// If this client is on another partial instance, no need
|
|
// to handle packets
|
|
//
|
|
if (!m_Client.IsActive && packet.Type != PacketType.LogoutRequest)
|
|
{
|
|
PacketPool.Instance.ReturnPacket(packet);
|
|
return;
|
|
}
|
|
|
|
if (packet.Type == PacketType.StartPingCheck)
|
|
{
|
|
StartPingCheckPacket startPing = (StartPingCheckPacket)packet;
|
|
CompletePingCheckPacket endPing
|
|
= (CompletePingCheckPacket)PacketPool.Instance.GetPacket(PacketType.CompletePingCheck);
|
|
|
|
endPing.PingID.PingID = startPing.PingID.PingID;
|
|
OutPacket(endPing, ThrottleOutPacketType.Task);
|
|
}
|
|
else
|
|
{
|
|
LLQueItem item = new LLQueItem();
|
|
item.Packet = packet;
|
|
item.Incoming = true;
|
|
m_PacketQueue.Enqueue(item);
|
|
}
|
|
}
|
|
|
|
public void ProcessInPacket(LLQueItem item)
|
|
{
|
|
Packet packet = item.Packet;
|
|
|
|
// Always ack the packet!
|
|
//
|
|
if (packet.Header.Reliable)
|
|
AckPacket(packet);
|
|
|
|
if (packet.Type != PacketType.AgentUpdate)
|
|
m_PacketsReceived++;
|
|
|
|
PruneDupeTracker();
|
|
|
|
// Check for duplicate packets.. packets that the client is
|
|
// resending because it didn't receive our ack
|
|
//
|
|
lock (m_DupeTracker)
|
|
{
|
|
if (m_DupeTracker.ContainsKey(packet.Header.Sequence))
|
|
return;
|
|
|
|
m_DupeTracker.Add(packet.Header.Sequence,
|
|
Util.UnixTimeSinceEpoch());
|
|
}
|
|
|
|
m_Client.ProcessInPacket(packet);
|
|
}
|
|
|
|
public void Flush()
|
|
{
|
|
m_PacketQueue.Flush();
|
|
m_UnackedBytes = (-1 * m_UnackedBytes);
|
|
SendPacketStats();
|
|
}
|
|
|
|
public void Clear()
|
|
{
|
|
m_UnackedBytes = (-1 * m_UnackedBytes);
|
|
SendPacketStats();
|
|
m_NeedAck.Clear();
|
|
m_PendingAcks.Clear();
|
|
m_Sequence += 1000000;
|
|
}
|
|
|
|
private void ProcessAck(uint id)
|
|
{
|
|
LLQueItem data;
|
|
|
|
lock (m_NeedAck)
|
|
{
|
|
//m_log.DebugFormat("[CLIENT]: In {0} received ack for packet {1}", m_Client.Scene.RegionInfo.ExternalEndPoint.Port, id);
|
|
|
|
if (!m_NeedAck.TryGetValue(id, out data))
|
|
return;
|
|
|
|
m_NeedAck.Remove(id);
|
|
m_PacketQueue.Cancel(data.Sequence);
|
|
PacketPool.Instance.ReturnPacket(data.Packet);
|
|
m_UnackedBytes -= data.Length;
|
|
}
|
|
}
|
|
|
|
// Allocate packet sequence numbers in a threadsave manner
|
|
//
|
|
protected uint NextPacketSequenceNumber()
|
|
{
|
|
// Set the sequence number
|
|
uint seq = 1;
|
|
lock (m_SequenceLock)
|
|
{
|
|
if (m_Sequence >= MAX_SEQUENCE)
|
|
{
|
|
m_Sequence = 1;
|
|
}
|
|
else
|
|
{
|
|
m_Sequence++;
|
|
}
|
|
seq = m_Sequence;
|
|
}
|
|
return seq;
|
|
}
|
|
|
|
public ClientInfo GetClientInfo()
|
|
{
|
|
ClientInfo info = new ClientInfo();
|
|
info.pendingAcks = m_PendingAcks;
|
|
info.needAck = new Dictionary<uint, byte[]>();
|
|
|
|
lock (m_NeedAck)
|
|
{
|
|
foreach (uint key in m_NeedAck.Keys)
|
|
info.needAck.Add(key, m_NeedAck[key].Packet.ToBytes());
|
|
}
|
|
|
|
LLQueItem[] queitems = m_PacketQueue.GetQueueArray();
|
|
|
|
for (int i = 0; i < queitems.Length; i++)
|
|
{
|
|
if (queitems[i].Incoming == false)
|
|
info.out_packets.Add(queitems[i].Packet.ToBytes());
|
|
}
|
|
|
|
info.sequence = m_Sequence;
|
|
|
|
float multiplier = m_PacketQueue.ThrottleMultiplier;
|
|
info.resendThrottle = (int) (m_PacketQueue.ResendThrottle.Throttle / multiplier);
|
|
info.landThrottle = (int) (m_PacketQueue.LandThrottle.Throttle / multiplier);
|
|
info.windThrottle = (int) (m_PacketQueue.WindThrottle.Throttle / multiplier);
|
|
info.cloudThrottle = (int) (m_PacketQueue.CloudThrottle.Throttle / multiplier);
|
|
info.taskThrottle = (int) (m_PacketQueue.TaskThrottle.Throttle / multiplier);
|
|
info.assetThrottle = (int) (m_PacketQueue.AssetThrottle.Throttle / multiplier);
|
|
info.textureThrottle = (int) (m_PacketQueue.TextureThrottle.Throttle / multiplier);
|
|
info.totalThrottle = (int) (m_PacketQueue.TotalThrottle.Throttle / multiplier);
|
|
|
|
return info;
|
|
}
|
|
|
|
public void SetClientInfo(ClientInfo info)
|
|
{
|
|
m_PendingAcks = info.pendingAcks;
|
|
m_NeedAck = new Dictionary<uint, LLQueItem>();
|
|
|
|
Packet packet = null;
|
|
int packetEnd = 0;
|
|
byte[] zero = new byte[3000];
|
|
|
|
foreach (uint key in info.needAck.Keys)
|
|
{
|
|
byte[] buff = info.needAck[key];
|
|
packetEnd = buff.Length - 1;
|
|
|
|
try
|
|
{
|
|
packet = PacketPool.Instance.GetPacket(buff, ref packetEnd, zero);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
}
|
|
|
|
LLQueItem item = new LLQueItem();
|
|
item.Packet = packet;
|
|
item.Incoming = false;
|
|
item.throttleType = 0;
|
|
item.TickCount = Environment.TickCount;
|
|
item.Identifier = 0;
|
|
item.Resends = 0;
|
|
item.Length = packet.Length;
|
|
item.Sequence = packet.Header.Sequence;
|
|
m_NeedAck.Add(key, item);
|
|
}
|
|
|
|
m_Sequence = info.sequence;
|
|
|
|
m_PacketQueue.ResendThrottle.Throttle = info.resendThrottle;
|
|
m_PacketQueue.LandThrottle.Throttle = info.landThrottle;
|
|
m_PacketQueue.WindThrottle.Throttle = info.windThrottle;
|
|
m_PacketQueue.CloudThrottle.Throttle = info.cloudThrottle;
|
|
m_PacketQueue.TaskThrottle.Throttle = info.taskThrottle;
|
|
m_PacketQueue.AssetThrottle.Throttle = info.assetThrottle;
|
|
m_PacketQueue.TextureThrottle.Throttle = info.textureThrottle;
|
|
m_PacketQueue.TotalThrottle.Throttle = info.totalThrottle;
|
|
}
|
|
|
|
public void AddImportantPacket(PacketType type)
|
|
{
|
|
if (m_ImportantPackets.Contains(type))
|
|
return;
|
|
|
|
m_ImportantPackets.Add(type);
|
|
}
|
|
|
|
public void RemoveImportantPacket(PacketType type)
|
|
{
|
|
if (!m_ImportantPackets.Contains(type))
|
|
return;
|
|
|
|
m_ImportantPackets.Remove(type);
|
|
}
|
|
|
|
private void DropResend(Object id)
|
|
{
|
|
foreach (LLQueItem data in new List<LLQueItem>(m_NeedAck.Values))
|
|
{
|
|
if (data.Identifier != null && data.Identifier == id)
|
|
{
|
|
m_NeedAck.Remove(data.Packet.Header.Sequence);
|
|
m_PacketQueue.Cancel(data.Sequence);
|
|
PacketPool.Instance.ReturnPacket(data.Packet);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void TriggerOnPacketDrop(Packet packet, Object id)
|
|
{
|
|
PacketDrop handlerPacketDrop = OnPacketDrop;
|
|
|
|
if (handlerPacketDrop == null)
|
|
return;
|
|
|
|
handlerPacketDrop(packet, id);
|
|
}
|
|
|
|
// Convert the packet to bytes and stuff it onto the send queue
|
|
//
|
|
public void ProcessOutPacket(LLQueItem item)
|
|
{
|
|
Packet packet = item.Packet;
|
|
|
|
// Assign sequence number here to prevent out of order packets
|
|
if (packet.Header.Sequence == 0)
|
|
{
|
|
packet.Header.Sequence = NextPacketSequenceNumber();
|
|
item.Sequence = packet.Header.Sequence;
|
|
item.TickCount = Environment.TickCount;
|
|
|
|
lock (m_NeedAck)
|
|
{
|
|
// We want to see that packet arrive if it's reliable
|
|
if (packet.Header.Reliable)
|
|
{
|
|
m_UnackedBytes += item.Length;
|
|
|
|
// Keep track of when this packet was sent out
|
|
item.TickCount = Environment.TickCount;
|
|
|
|
m_NeedAck[packet.Header.Sequence] = item;
|
|
}
|
|
}
|
|
}
|
|
|
|
// If we sent a killpacket
|
|
if (packet is KillPacket)
|
|
Abort();
|
|
|
|
// Actually make the byte array and send it
|
|
byte[] sendbuffer = item.Packet.ToBytes();
|
|
|
|
//m_log.DebugFormat(
|
|
// "[CLIENT]: In {0} sending packet {1}",
|
|
// m_Client.Scene.RegionInfo.ExternalEndPoint.Port, packet.Header.Sequence);
|
|
|
|
if (packet.Header.Zerocoded)
|
|
{
|
|
int packetsize = Helpers.ZeroEncode(sendbuffer,
|
|
sendbuffer.Length, m_ZeroOutBuffer);
|
|
m_PacketServer.SendPacketTo(m_ZeroOutBuffer, packetsize,
|
|
SocketFlags.None, m_Client.CircuitCode);
|
|
}
|
|
else
|
|
{
|
|
// Need some extra space in case we need to add proxy
|
|
// information to the message later
|
|
Buffer.BlockCopy(sendbuffer, 0, m_ZeroOutBuffer, 0,
|
|
sendbuffer.Length);
|
|
m_PacketServer.SendPacketTo(m_ZeroOutBuffer,
|
|
sendbuffer.Length, SocketFlags.None, m_Client.CircuitCode);
|
|
}
|
|
|
|
// If this is a reliable packet, we are still holding a ref
|
|
// Dont't return in that case
|
|
//
|
|
if (!packet.Header.Reliable)
|
|
{
|
|
m_PacketQueue.Cancel(item.Sequence);
|
|
PacketPool.Instance.ReturnPacket(packet);
|
|
}
|
|
}
|
|
|
|
private void Abort()
|
|
{
|
|
m_PacketQueue.Close();
|
|
Thread.CurrentThread.Abort();
|
|
}
|
|
}
|
|
}
|