public override void Send(byte[] buffer, byte channelID = 0, PacketFlags flags = PacketFlags.Reliable)
{
if (this.Id == 0)
{
throw new Exception("UChannel已经被Dispose, 不能发送消息");
}
this.socket.SendAsync(buffer, channelID, flags);
}
/// <summary>
/// Initializes a new instance of <see cref="Kamilla.Network.Protocols.Wow.WowPacket"/> class.
/// </summary>
/// <param name="data">
/// Data of the new <see cref="Kamilla.Network.Protocols.Wow.WowPacket"/>.
/// </param>
/// <param name="direction">
/// <see cref="Kamilla.Network.TransferDirection"/> of
/// the new <see cref="Kamilla.Network.Protocols.Wow.WowPacket"/>.
/// </param>
/// <param name="flags">
/// The <see cref="Kamilla.Network.PacketFlags"/> of
/// the new <see cref="Kamilla.Network.Protocols.Wow.WowPacket"/>.
/// </param>
/// <param name="wowFlags">
/// The <see cref="Kamilla.Network.Protocols.Wow.WowPacketFlags"/> of
/// the new <see cref="Kamilla.Network.Protocols.Wow.WowPacket"/>.
/// </param>
/// <param name="arrivalTicks">
/// Number of milliseconds passed from the Operation System start to the packet arrival event.
/// </param>
/// <param name="arrivalTime">
/// An instance of <see cref="System.DateTime"/> representing the moment when
/// the packet <see cref="Kamilla.Network.Protocols.Wow.WowPacket"/> arrived.
/// </param>
/// <param name="opcode">
/// The opcode of the new <see cref="Kamilla.Network.Protocols.Wow.WowPacket"/>.
/// </param>
/// <param name="connectionId">
/// The connection id of the new <see cref="Kamilla.Network.Protocols.Wow.WowPacket"/>.
/// </param>
public WowPacket(byte[] data, TransferDirection direction, PacketFlags flags, WowPacketFlags wowFlags,
DateTime arrivalTime, uint arrivalTicks, uint opcode, int connectionId)
: base(data, direction, flags, arrivalTime, arrivalTicks)
{
m_opcode = opcode;
m_connectionId = connectionId;
m_wowFlags = wowFlags;
}
/// <summary>
/// Initializes a new instance of <see cref="Kamilla.Network.Packet"/> class
/// with the specified data, <see cref="Kamilla.Network.TransferDirection"/>,
/// <see cref="Kamilla.Network.PacketFlags"/>, and arrival time and ticks.
/// </summary>
/// <param name="data">
/// Data of the new <see cref="Kamilla.Network.Packet"/>.
/// </param>
/// <param name="direction">
/// <see cref="Kamilla.Network.TransferDirection"/> of the new <see cref="Kamilla.Network.Packet"/>.
/// </param>
/// <param name="flags">
/// <see cref="Kamilla.Network.PacketFlags"/> of the new <see cref="Kamilla.Network.Packet"/>.
/// </param>
/// <param name="arrivalTicks">
/// Number of milliseconds passed from the Operation System start to the packet arrival event.
/// </param>
/// <param name="arrivalTime">
/// An instance of <see cref="System.DateTime"/> representing the moment when
/// the packet <see cref="Kamilla.Network.Packet"/> arrived.
/// </param>
public Packet(byte[] data, TransferDirection direction, PacketFlags flags,
DateTime arrivalTime, uint arrivalTicks)
{
m_arrivalDateTime = arrivalTime;
m_arrivalTicks = arrivalTicks;
m_data = data;
m_direction = direction;
m_flags = flags;
}
/// <summary>
/// Sets the value of the specified flag.
/// </summary>
protected void SetFlag(PacketFlags flag, bool value)
{
if (value)
{
_packetFlags |= flag;
}
else
{
_packetFlags &= ~flag;
}
}
public override void SendAsync(
byte[] buffer, byte channelID = 0, PacketFlags flags = PacketFlags.Reliable)
{
if (!this.isConnected)
{
BufferInfo info = new BufferInfo { Buffer = buffer, ChannelID = channelID, Flags = flags };
this.queue.Enqueue(info);
return;
}
this.socket.SendAsync(buffer, channelID, flags);
}
public UPacket(byte[] data, PacketFlags flags = PacketFlags.None)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
this.packet = NativeMethods.ENetPacketCreate(data, (uint) data.Length, flags);
if (this.packet == IntPtr.Zero)
{
throw new UException("Packet creation call failed");
}
}
public void Create(byte[] data, int length, PacketFlags flags)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
if (length < 0 || length > data.Length)
{
throw new ArgumentOutOfRangeException();
}
nativePacket = Native.enet_packet_create(data, (IntPtr)length, flags);
}
public override void Send(byte[] buffer, byte channelID = 0, PacketFlags flags = PacketFlags.Reliable)
{
if (this.Id == 0)
{
throw new Exception("TChannel已经被Dispose, 不能发送消息");
}
byte[] size = BitConverter.GetBytes((ushort)buffer.Length);
this.sendBuffer.SendTo(size);
this.sendBuffer.SendTo(buffer);
if (this.isConnected)
{
this.StartSend();
}
}
private static bool Broadcast(byte[] buffer, Channel channelNo, PacketFlags packetFlags = PacketFlags.None)
{
if (buffer.Length >= 8)
{
buffer = BlowFish.Encrypt(buffer);
fixed(byte *b = buffer)
{
var packet = enet_packet_create(new IntPtr(b), new IntPtr(buffer.Length), packetFlags);
enet_host_broadcast(LoLServer.GetServer(), (byte)channelNo, packet);
}
return(true);
}
public void Create(IntPtr data, int offset, int length, PacketFlags flags)
{
if (data == IntPtr.Zero)
{
throw new ArgumentNullException("data");
}
if (offset < 0 || length < 0)
{
throw new ArgumentOutOfRangeException();
}
nativePacket = Native.enet_packet_create_offset(data, (IntPtr)length, (IntPtr)offset, flags);
}
public void Send(MessageType type, Peer peer, byte[] data, PacketFlags flags)
{
Packet packet = default(Packet);
byte[] buffer = new byte[MessageConfig.MESSAGE_LEN + data.Length];
byte[] byteType = BitConverter.GetBytes((ushort)type);
Array.Copy(byteType, buffer, MessageConfig.MESSAGE_LEN);
Array.Copy(data, 0, buffer, MessageConfig.MESSAGE_LEN, data.Length);
packet.Create(buffer, flags);
peer.Send(0, ref packet);
}
public void Create(byte[] data, int offset, int length, PacketFlags flags)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
if (offset < 0 || length < 0 || length > data.Length - offset)
{
throw new ArgumentOutOfRangeException();
}
_packet = new LENet.Packet((uint)length, (LENet.PacketFlags)flags);
Array.Copy(data, offset, _packet.Data, 0, length);
}
public override void Send(List <byte[]> buffers, byte channelID = 0, PacketFlags flags = PacketFlags.Reliable)
{
int size = buffers.Select(b => b.Length).Sum();
byte[] sizeBuffer = BitConverter.GetBytes(size);
this.sendBuffer.SendTo(sizeBuffer);
foreach (byte[] buffer in buffers)
{
this.sendBuffer.SendTo(buffer);
}
if (!this.isSending && this.isConnected)
{
this.StartSend();
}
}
/// <summary>
/// Send a message to an array of clients.
/// </summary>
/// <param name="message">The message to send</param>
/// <param name="clients">The clients to send to</param>
/// <param name="channel">The channel to send the message through</param>
private void SendMessage(Message message, PacketFlags flags, byte channel, IClient[] clients)
{
// Extract the array of peers from the clients
// TODO: Figure out a more efficient way for this.
int length = clients.Length;
Peer[] peers = new Peer[length];
for (int i = 0; i < length; ++i)
{
ClientManager.TryGetClient(clients[i].Id, out var client);
peers[i] = client.Peer;
}
SendMessage(message, flags, channel, peers);
}
public void SendAsync(byte[] data, byte channelID = 0, PacketFlags flags = PacketFlags.Reliable)
{
if (!isConnected)
{
sendQueue.Enqueue(new BufferInfo {
Buffer = data, ChannelID = channelID, Flags = flags
});
return;
}
UPacket packet = new UPacket(data, flags);
NativeMethods.ENetPeerSend(this.PeerPtr, channelID, packet.PacketPtr);
// enet_peer_send函数会自动删除packet,设置为0,防止Dispose或者析构函数再次删除
packet.PacketPtr = IntPtr.Zero;
}
public void Create(byte[] data, int offset, int length, PacketFlags flags)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
if (offset < 0 || length < 0 || length > data.Length - offset)
{
throw new ArgumentOutOfRangeException();
}
fixed(byte *bytes = data)
{
Create(bytes + offset, length, flags);
}
}
public override void Send(List<byte[]> buffers, byte channelID = 0, PacketFlags flags = PacketFlags.Reliable)
{
if (this.Id == 0)
{
throw new Exception("UChannel已经被Dispose, 不能发送消息");
}
int size = buffers.Select(b => b.Length).Sum();
var buffer = new byte[size];
int index = 0;
foreach (byte[] bytes in buffers)
{
Array.Copy(bytes, 0, buffer, index, bytes.Length);
index += bytes.Length;
}
this.socket.SendAsync(buffer, channelID, flags);
}
public EchoServer(Configuration config, BenchmarkStatistics benchmarkStatistics) : base(config)
{
this.config = config;
this.benchmarkStatistics = benchmarkStatistics;
timeout = Utilities.CalculateTimeout(this.config.ServerTickRate);
packetFlags = ENetBenchmark.GetPacketFlags(config.Transmission);
host = new Host();
address = new Address();
address.Port = (ushort)config.Port;
address.SetHost(config.Address);
serverThread = new Thread(ListenLoop);
serverThread.Name = "Enet Server";
serverThread.Priority = ThreadPriority.AboveNormal;
}
protected Queue <NetQItem> m_SendQueue = new Queue <NetQItem>(); // packet send queue
/// <summary>
/// Sends arbitrary bytes of data across the wire. Note that if the remote endpoint can't decipher the data
/// as a known packet, the connection will be dropped by that endpoint immediately.
/// </summary>
/// <param name="data">bytes to send</param>
public virtual int Send(byte[] data, PacketFlags flags)
{
//Log.LogMsg("@__@ Monitor Enter");
if (!OwningConnection.IsAlive)
{
return(-1);
}
//Log.LogMsg("==>Sending " + data.Length.ToString() + " bytes.");
try
{
bool isUDP = (flags & PacketFlags.UDP) != 0;
if (isUDP)
{
if (!OwningConnection.CanSendUDP)
{
Log.LogMsg("!!! Tried sending UDP packet when the connection wasn't yet ready to send UDP. Dropping packet.");
return(0);
}
// Don't allow fragmenting UDP packets
if (data.Length > 1024)
{
Log.LogMsg("Message exceeded UDP size of 1024 bytes. Sending via TCP instead.");
flags &= ~PacketFlags.UDP;
}
}
lock (m_SendQueue)
{
NetQItem qi = new NetQItem();
qi.Flags = flags;
qi.Data = data;
qi.IsUDP = isUDP;
m_SendQueue.Enqueue(qi);
Monitor.Pulse(m_SendQueue);
return(1);
}
}
catch (Exception sendExc)
{
return(-1);;
}
return(1);
}
public bool sendPacket(Peer peer, byte[] source, Channel channelNo, PacketFlags flag = PacketFlags.Reliable)
{
////PDEBUG_LOG_LINE(Logging," Sending packet:\n");
//if(length < 300)
//printPacket(source, "Sent: ");
byte[] temp;
if (source.Length >= 8)
{
temp = _game.GetBlowfish().Encrypt(source);
}
else
{
temp = source;
}
return(peer.Send((byte)channelNo, temp));
}
public bool Send(byte[] buffer, Channel channelNo, PacketFlags flag = PacketFlags.Reliable)
{
if (buffer.Length >= 8)
{
buffer = LoLServer.BlowFish.Encrypt(buffer);
fixed(byte *data = buffer)
{
var packet = enet_packet_create(new IntPtr(data), new IntPtr(buffer.Length), flag);
if (enet_peer_send(Peer, (byte)channelNo, packet) < 0)
{
return(false);
}
}
return(true);
}
public void Create(byte[] data, int offset, int length, PacketFlags flags)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
if (offset < 0 || length < 0 || length > data.Length - offset)
{
throw new ArgumentOutOfRangeException();
}
var ptr = Marshal.AllocHGlobal(length);
Marshal.Copy(data, offset, ptr, length);
Create(ptr, length, flags);
Marshal.FreeHGlobal(ptr);
}
public override void Send(List <byte[]> buffers, byte channelID = 0, PacketFlags flags = PacketFlags.Reliable)
{
if (this.Id == 0)
{
throw new Exception("UChannel已经被Dispose, 不能发送消息");
}
int size = buffers.Select(b => b.Length).Sum();
var buffer = new byte[size];
int index = 0;
foreach (byte[] bytes in buffers)
{
Array.Copy(bytes, 0, buffer, index, bytes.Length);
index += bytes.Length;
}
this.socket.SendAsync(buffer, channelID, flags);
}
public void Send(uint peerId, byte[] data, byte channelId, PacketFlags flags)
{
try
{
var packet = default(Packet);
packet.Create(data, flags);
var peer = FindPeer(peerId);
if (peer.IsSet)
{
peer.Send(channelId, ref packet);
}
}
catch (Exception e)
{
UnityEngine.Debug.Log("ERROR Send : " + e);
}
}
public bool BroadcastPacketVision(IGameObject o, byte[] data, Channel channelNo,
PacketFlags flag = PacketFlags.Reliable)
{
foreach (var team in _teamsEnumerator)
{
if (team == TeamId.TEAM_NEUTRAL)
{
continue;
}
if (_game.ObjectManager.TeamHasVisionOn(team, o))
{
BroadcastPacketTeam(team, data, channelNo, flag);
}
}
return(true);
}
public EchoClient(int id, Configuration config, BenchmarkStatistics benchmarkStatistics) : base(config)
{
this.id = id;
this.config = config;
this.benchmarkStatistics = benchmarkStatistics;
timeout = Utilities.CalculateTimeout(this.config.ClientTickRate);
packetFlags = ENetBenchmark.GetPacketFlags(config.Transmission);
host = new Host();
address = new Address();
address.SetHost(config.Address);
address.Port = (ushort)config.Port;
isDisposed = false;
listenThread = new Thread(ListenLoop);
listenThread.Name = $"ENet Client {id}";
listenThread.IsBackground = true;
}
public bool SendPacket(int userId, byte[] source, Channel channelNo, PacketFlags flag = PacketFlags.Reliable)
{
byte[] temp;
if (source.Length >= 8)
{
temp = _blowfish.Encrypt(source);
}
else
{
temp = source;
}
// sometimes we want to send packets to some user but this user doesn't exist (like in broadcast when not all players connected)
if (_peers.ContainsKey(userId))
{
return(_peers[userId].Send((byte)channelNo, temp));
}
return(false);
}
public bool BroadcastPacket(byte[] data, Channel channelNo, PacketFlags flag = PacketFlags.Reliable)
{
byte[] temp;
if (data.Length >= 8)
{
temp = _blowfish.Encrypt(data);
}
else
{
temp = data;
}
var packet = new ENet.Packet();
packet.Create(temp);
_server.Broadcast((byte)channelNo, ref packet);
return(true);
}
// v1.4.0b6: Mirror rearranged the ClientSend params, so we need to apply a fix for that or
// we end up using the obsoleted version. The obsolete version isn't a fatal error, but
// it's best to stick with the new structures.
public override void ClientSend(ArraySegment <byte> segment, int channelId)
#endif
{
if (Client == null)
{
Debug.LogError("Client object is null, this shouldn't really happen but it did...");
return;
}
if (channelId < 0 || channelId > Channels.Length)
{
Debug.LogError("Channel ID is out of bounds.");
return;
}
// Create our struct...
Packet clientOutgoingPacket = default;
int byteCount = segment.Count;
int byteOffset = segment.Offset;
// Set our desired flags...
PacketFlags desiredFlags = (PacketFlags)Channels[channelId];
// Warn if over recommended MTU...
bool flagsSet = (desiredFlags & ReliableOrUnreliableFragmented) > 0;
if (LogType != IgnoranceLogType.Nothing && byteCount > 1200 && !flagsSet)
{
Debug.LogWarning($"Warning: Client trying to send a Unreliable packet bigger than the recommended ENet 1200 byte MTU ({byteCount} > 1200). ENet will force Reliable Fragmented delivery.");
}
// Create the packet.
clientOutgoingPacket.Create(segment.Array, byteOffset, byteCount + byteOffset, desiredFlags);
// byteCount
// Enqueue the packet.
IgnoranceOutgoingPacket dispatchPacket = new IgnoranceOutgoingPacket
{
Channel = (byte)channelId,
Payload = clientOutgoingPacket
};
// Pass the packet onto the thread for dispatch.
Client.Outgoing.Enqueue(dispatchPacket);
}
// v1.4.0b6: Mirror rearranged the ServerSend params, so we need to apply a fix for that or
// we end up using the obsoleted version. The obsolete version isn't a fatal error, but
// it's best to stick with the new structures.
public override void ServerSend(int connectionId, ArraySegment <byte> segment, int channelId)
#endif
{
// Debug.Log($"ServerSend({connectionId}, {channelId}, <{segment.Count} byte segment>)");
if (Server == null)
{
Debug.LogError("Cannot enqueue data packet; our Server object is null. Something has gone wrong.");
return;
}
if (channelId < 0 || channelId > Channels.Length)
{
Debug.LogError("Channel ID is out of bounds.");
return;
}
// Packet Struct
Packet serverOutgoingPacket = default;
int byteCount = segment.Count;
int byteOffset = segment.Offset;
PacketFlags desiredFlags = (PacketFlags)Channels[channelId];
// Warn if over recommended MTU
bool flagsSet = (desiredFlags & ReliableOrUnreliableFragmented) > 0;
if (LogType != IgnoranceLogType.Nothing && byteCount > 1200 && !flagsSet)
{
Debug.LogWarning($"Warning: Server trying to send a Unreliable packet bigger than the recommended ENet 1200 byte MTU ({byteCount} > 1200). ENet will force Reliable Fragmented delivery.");
}
// Create the packet.
serverOutgoingPacket.Create(segment.Array, byteOffset, byteCount + byteOffset, (PacketFlags)Channels[channelId]);
// Enqueue the packet.
IgnoranceOutgoingPacket dispatchPacket = new IgnoranceOutgoingPacket
{
Channel = (byte)channelId,
NativePeerId = (uint)connectionId - 1, // ENet's native peer ID will be ConnID - 1
Payload = serverOutgoingPacket
};
Server.Outgoing.Enqueue(dispatchPacket);
}
private void _read()
{
_transactionId = m_io.ReadU2be();
_flags = new PacketFlags(m_io, this, m_root);
_qdcount = m_io.ReadU2be();
_ancount = m_io.ReadU2be();
_nscount = m_io.ReadU2be();
_arcount = m_io.ReadU2be();
_queries = new List <Query>((int)(Qdcount));
for (var i = 0; i < Qdcount; i++)
{
_queries.Add(new Query(m_io, this, m_root));
}
_answers = new List <Answer>((int)(Ancount));
for (var i = 0; i < Ancount; i++)
{
_answers.Add(new Answer(m_io, this, m_root));
}
}
public override void Send(List <byte[]> buffers, byte channelID = 0, PacketFlags flags = PacketFlags.Reliable)
{
if (this.Id == 0)
{
throw new Exception("TChannel已经被Dispose, 不能发送消息");
}
ushort size = (ushort)buffers.Select(b => b.Length).Sum();
byte[] sizeBuffer = BitConverter.GetBytes(size);
this.sendBuffer.SendTo(sizeBuffer);
foreach (byte[] buffer in buffers)
{
this.sendBuffer.SendTo(buffer);
}
if (this.isConnected)
{
this.StartSend();
}
}
public bool broadcastPacket(byte[] data, Channel channelNo, PacketFlags flag = PacketFlags.Reliable)
{
////PDEBUG_LOG_LINE(Logging," Broadcast packet:\n");
//printPacket(data, "Broadcast: ");
Sniffer.getInstance().Send(data, true, true);
fixed(byte *b = data)
{
if (data.Length >= 8)
{
BlowFishCS.BlowFishCS.Encrypt1(game.getBlowfish(), b, new IntPtr(data.Length - (data.Length % 8)));
}
var packet = enet_packet_create(new IntPtr(b), new IntPtr(data.Length), (PacketFlags)flag);
enet_host_broadcast(game.getServer(), (byte)channelNo, packet);
}
return(true);
}
public bool broadcastPacket(byte[] data, Channel channelNo, PacketFlags flag = PacketFlags.Reliable)
{
////PDEBUG_LOG_LINE(Logging," Broadcast packet:\n");
//printPacket(data, "Broadcast: ");
byte[] temp;
if (data.Length >= 8)
{
temp = _blowfish.Encrypt(data);
}
else
{
temp = data;
}
var packet = new Packet();
packet.Create(temp);
_server.Broadcast((byte)channelNo, ref packet);
return(true);
}
public bool broadcastPacketVision(GameObject o, byte[] data, Channel channelNo,
PacketFlags flag = PacketFlags.Reliable)
{
var game = Program.ResolveDependency <Game>();
foreach (var team in _teamsEnumerator)
{
if (team == TeamId.TEAM_NEUTRAL)
{
continue;
}
if (game.ObjectManager.TeamHasVisionOn(team, o))
{
broadcastPacketTeam(team, data, channelNo, flag);
}
}
return(true);
}
public StreamingPacket(BufRefLen reader)
{
SendStreamId = reader.ReadFlip32();
ReceiveStreamId = reader.ReadFlip32();
SequenceNumber = reader.ReadFlip32();
AckTrhough = reader.ReadFlip32();
NACKs = new List <uint>();
var nackcount = reader.Read8();
for (int i = 0; i < nackcount; ++i)
{
NACKs.Add(reader.ReadFlip32());
}
ResendDelay = reader.Read8();
Flags = (PacketFlags)reader.ReadFlip16();
var optionsize = reader.ReadFlip16();
// Options order
// DELAY_REQUESTED
// FROM_INCLUDED
if ((Flags & PacketFlags.FROM_INCLUDED) != 0)
{
From = new I2PDestination(reader);
}
// MAX_PACKET_SIZE_INCLUDED
if ((Flags & PacketFlags.MAX_PACKET_SIZE_INCLUDED) != 0)
{
var mtu = reader.ReadFlip16();
}
// OFFLINE_SIGNATURE
// SIGNATURE_INCLUDED
if ((Flags & PacketFlags.SIGNATURE_INCLUDED) != 0)
{
Signature = new I2PSignature(reader, From.Certificate);
}
Payload = reader.ReadBufLen(reader.Length);
}
private E <string> AddOutgoingSplitData(ReadOnlySpan <byte> rawData, PacketType packetType, PacketFlags addFlags = PacketFlags.None)
{
int pos = 0;
bool first = true;
bool last;
// TODO check if "packBuffer.FreeSlots >= packetSplit.Count"
do
{
int blockSize = Math.Min(MaxOutContentSize, rawData.Length - pos);
if (blockSize <= 0)
{
break;
}
var flags = PacketFlags.None;
last = pos + blockSize == rawData.Length;
if (first ^ last)
{
flags |= PacketFlags.Fragmented;
}
if (first)
{
flags |= addFlags;
first = false;
}
Debug.Assert(!NeedsSplitting(blockSize));
var sendResult = SendOutgoingData(rawData.Slice(pos, blockSize), packetType, flags);
if (!sendResult.Ok)
{
return(sendResult);
}
pos += blockSize;
} while (!last);
return(R.Ok);
}
public PacketHeader(byte type, byte subtype, PacketFlags packetFlags) : this(type, subtype, (byte)packetFlags)
{
}
private void SetFlag(PacketFlags flag)
{
this.Flags |= flag;
}
public void UnloadCharacter()
{
if (mChannel != null)
ChannelMgr.Leave(this);
mClientFlags = PacketFlags.Login;
mPlace = MMatchPlace.Outside;
mCharacter = new MTD_CharInfo();
}
public void Create(void* data, int length, PacketFlags flags)
{
if (_packet != null)
{
throw new InvalidOperationException("Already created.");
}
_packet = Native.enet_packet_create(data, (IntPtr) length, flags);
if (_packet == null)
{
throw new ENetException(0, "Packet creation call failed.");
}
}
internal static extern IntPtr ENetPacketCreate(byte[] data, uint dataLength, PacketFlags flags);
public override void SendAsync(
List<byte[]> buffers, byte channelID = 0, PacketFlags flags = PacketFlags.Reliable)
{
int size = buffers.Select(b => b.Length).Sum();
byte[] buffer = new byte[size];
int index = 0;
foreach (byte[] bytes in buffers)
{
Array.Copy(bytes, 0, buffer, index, bytes.Length);
index += bytes.Length;
}
if (!this.isConnected)
{
BufferInfo info = new BufferInfo { Buffer = buffer, ChannelID = channelID, Flags = flags };
this.queue.Enqueue(info);
return;
}
this.socket.SendAsync(buffer, channelID, flags);
}
private void RemoveFlag(PacketFlags flag)
{
this.Flags &= ~flag;
}
public override ENetPacket* packet_create(IntPtr data, IntPtr dataLength, PacketFlags flags)
{
return native_packet_create(data, dataLength, flags);
}
static extern ENetPacket* native_packet_create(IntPtr data, IntPtr dataLength, PacketFlags flags);
/// <summary> /// 发送消息 /// </summary> public abstract void Send(byte[] buffer, byte channelID = 0, PacketFlags flags = PacketFlags.Reliable);
/// <summary>
/// Sends arbitrary bytes of data across the wire. Note that if the remote endpoint can't decipher the data
/// as a known packet, the connection will be dropped by that endpoint immediately.
/// </summary>
/// <param name="data">bytes to send</param>
public virtual int Send(byte[] data, PacketFlags flags)
{
//Log.LogMsg("@__@ Monitor Enter");
if (!OwningConnection.IsAlive)
{
//// Log.LogMsg("Testy 3");
return -1;
}
//Log.LogMsg("==>Sending " + data.Length.ToString() + " bytes.");
try
{
bool isUDP = (flags & PacketFlags.UDP) != 0;
#if SILVERLIGHT
// Silverlight can't do UDP and it can only send Async, i.e. Non-Blocking
isUDP = false;
OwningConnection.BlockingMode = false;
#endif
if (isUDP)
{
//// Log.LogMsg("Testy 4");
if (!OwningConnection.CanSendUDP)
{
Log.LogMsg("!!! Tried sending UDP packet when the connection wasn't yet ready to send UDP. Dropping packet.");
return 0;
}
// Don't allow fragmenting UDP packets
if (data.Length > m_SendArgsUDP.Buffer.Length && data.Length > 1024)
{
Log.LogMsg("Message exceeded UDP size. Sending via TCP instead.");
flags &= ~PacketFlags.UDP;
}
}
if (!OwningConnection.BlockingMode)
{
// send via asyncsend, but only one send op can be in progress at one time
// out of order packets can happen because the actual send is done with I/O completion ports and if multiple
// packets get submitted to the I/O queue they could be processed out of order, especially if the packet are of wildly differing sizes
if (isUDP)
{
//// Log.LogMsg("Testy 5");
lock (m_SendQueueUDP)
{
if (1 == Interlocked.Exchange(ref m_SendingUDP, 1))
{
// failed to get the lock - a message is in progress. queue message.
NetQItem qi = new NetQItem();
qi.Flags = flags;
qi.Data = data;
m_SendQueueUDP.Enqueue(qi);
Log.LogMsg("Queueing UDP packet. Now " + m_SendQueueUDP.Count.ToString() + " in Queue.");
return 1;
}
//Log.LogMsg("Acquired UDP send lock.");
}
}
else
{
lock (m_SendQueue)
{
if (1 == Interlocked.Exchange(ref m_Sending, 1))
{
// failed to get the lock - a message is in progress. queue message.
NetQItem qi = new NetQItem();
qi.Flags = flags;
qi.Data = data;
m_SendQueue.Enqueue(qi);
Log.LogMsg("Queueing TCP packet. Now " + m_SendQueue.Count.ToString() + " in Queue.");
return 1;
}
//Log.LogMsg("Acquired TCP send lock.");
}
}
}
SocketAsyncEventArgs args = isUDP ? m_SendArgsUDP : m_SendArgs;
SockState state = args.UserToken as SockState;
state.Flags = flags;
state.PacketBuffer = data;
//// Log.LogMsg("Testy 6");
SendBuffer(args, state, isUDP);
}
catch (Exception sendExc)
{
OwningConnection.KillConnection(sendExc.Message);
return -1; ;
}
return 1;
}
public static extern ENetPacket* enet_packet_create(void* data, IntPtr dataLength, PacketFlags flags);
public abstract void Send(List<byte[]> buffers, byte channelID = 0, PacketFlags flags = PacketFlags.Reliable);
/// <summary>
/// Sends arbitrary bytes of data across the wire. Note that if the remote endpoint can't decipher the data
/// as a known packet, the connection will be dropped by that endpoint immediately.
/// </summary>
/// <param name="data">bytes to send</param>
public virtual int Send(byte[] data, PacketFlags flags)
{
//Log.LogMsg("@__@ Monitor Enter");
if (!OwningConnection.IsAlive)
{
return -1;
}
//Log.LogMsg("==>Sending " + data.Length.ToString() + " bytes.");
try
{
bool isUDP = (flags & PacketFlags.UDP) != 0;
if (isUDP)
{
if (!OwningConnection.CanSendUDP)
{
Log.LogMsg("!!! Tried sending UDP packet when the connection wasn't yet ready to send UDP. Dropping packet.");
return 0;
}
// Don't allow fragmenting UDP packets
if (data.Length > 1024)
{
Log.LogMsg("Message exceeded UDP size of 1024 bytes. Sending via TCP instead.");
flags &= ~PacketFlags.UDP;
}
}
lock (m_SendQueue)
{
NetQItem qi = new NetQItem();
qi.Flags = flags;
qi.Data = data;
qi.IsUDP = isUDP;
m_SendQueue.Enqueue(qi);
Monitor.Pulse(m_SendQueue);
return 1;
}
}
catch (Exception sendExc)
{
return -1; ;
}
return 1;
}
public abstract ENetPacket* packet_create(IntPtr data, IntPtr dataLength, PacketFlags flags);
private bool IsFlagSet(PacketFlags flag)
{
return (this.Flags & flag) != 0;
}
/// <summary>
/// Gets the value of the specified flag.
/// </summary>
protected bool GetFlag(PacketFlags flag)
{
return (_packetFlags & flag) == flag;
}
private Packet CreatePacket(int type, int subType, PacketFlags flags, byte[] data)
{
Packet p = CreatePacket(type, subType, false, false);
if (p != null)
{
p.Flags = flags;
p.PacketTypeID = type;
p.PacketSubTypeID = subType;
//Log.LogMsg("Attempting to deserialize " + (p.IsUDP? "UDP" : "TCP") + " packet "+ p.PacketTypeID.ToString());
p.DeSerialize(data, new Pointer());
//Log.LogMsg("Deserialized " + (p.IsUDP? "UDP" : "TCP") + " packet " + p.GetType().ToString());
}
return p;
}
public static ENetPacket* enet_packet_create(IntPtr data, IntPtr dataLength, PacketFlags flags)
{
return Platform.packet_create(data, dataLength, flags);
}
public HandlerDelegate(PacketProcessor pAction, PacketFlags pFlags)
{
mProcessor = pAction;
mFlags = pFlags;
}
/// <summary>
///
/// </summary>
/// <param name="channelId"></param>
/// <param name="data"></param>
/// <param name="flags"></param>
private void Send(byte channelId, byte[] data, PacketFlags flags)
{
try
{
m_peer.Send(channelId, data, flags);
}
catch(Exception e)
{
}
}
public void Create(byte[] data, int offset, int length, PacketFlags flags)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
if (offset < 0 || length < 0 || length > data.Length - offset)
{
throw new ArgumentOutOfRangeException();
}
fixed (byte* bytes = data)
{
Create(bytes + offset, length, flags);
}
}
public void SendAsync(byte[] data, byte channelID = 0, PacketFlags flags = PacketFlags.Reliable)
{
if (this.PeerPtr == IntPtr.Zero)
{
throw new Exception($"USocket 已经被Dispose,不能发送数据!");
}
if (!isConnected)
{
sendQueue.Enqueue(new BufferInfo { Buffer = data, ChannelID = channelID, Flags = flags });
return;
}
UPacket packet = new UPacket(data, flags);
NativeMethods.ENetPeerSend(this.PeerPtr, channelID, packet.PacketPtr);
// enet_peer_send函数会自动删除packet,设置为0,防止Dispose或者析构函数再次删除
packet.PacketPtr = IntPtr.Zero;
}