// Params:
// Accept: 0, 0
// Disconnect: InternalReason, UserReason
// Ping: PingSeq, Loss
// Pong: PingSeq, Dropped
internal static int PackProtocol(byte[] buffer, NetPacketType type, byte firstParam, byte secondParam)
{
buffer[0] = (byte)type;
buffer[1] = firstParam;
buffer[2] = secondParam;
return(PROTOCOL_HEADER_SIZE);
}
/// <summary>
/// Registers the given function delegate to the given packet type.
/// </summary>
/// <param name="type">packet type to handle</param>
/// <param name="handler">function delegate designed to handle it</param>
public void Unbind(NetPacketType type, MessageDelegate handler)
{
if (handlers.ContainsKey(type))
{
handlers[type] -= handler;
}
}
public void TestProtocol()
{
byte[] buffer = new byte[100];
NetPacketType type = NetPacketType.Kick;
byte firstParam = 0xAF;
byte secondParam = 0xFA;
int bytesPacked =
NetEncoding.PackProtocol(
buffer,
type,
firstParam,
secondParam);
byte firstParamRead;
byte secondParamRead;
bool success =
NetEncoding.ReadProtocol(
buffer,
bytesPacked,
out firstParamRead,
out secondParamRead);
Assert.AreEqual(0, buffer[bytesPacked]);
Assert.AreEqual(NetPacketType.Kick, NetEncoding.GetType(buffer));
Assert.AreEqual(true, success);
Assert.AreEqual(firstParam, firstParamRead);
Assert.AreEqual(secondParam, secondParamRead);
}
bool IsPacketConnectionless(NetPacketType type)
{
return
(type == NetPacketType.ConnectionApproved ||
type == NetPacketType.ConnectionDenied ||
type == NetPacketType.ConnectionRequest ||
type == NetPacketType.ConnectionReady ||
type == NetPacketType.Disconnected);
}
/// <summary>
/// Polls the socket and receives all pending packet data.
/// </summary>
private void ReadPackets()
{
for (int i = 0; i < NetConfig.MaxPacketReads; i++)
{
IPEndPoint source;
byte[] buffer;
int length;
SocketError result =
this.receiver.TryReceive(out source, out buffer, out length);
if (NetSocket.Succeeded(result) == false)
{
return;
}
NetPacketType type = NetEncoding.GetType(buffer);
if (type == NetPacketType.Connect)
{
// We don't have a peer yet -- special case
this.HandleConnectRequest(source, buffer, length);
}
else
{
NetPeer peer;
if (this.peers.TryGetValue(source, out peer))
{
switch (type)
{
case NetPacketType.Accept:
this.HandleConnectAccept(peer, buffer, length);
break;
case NetPacketType.Kick:
this.HandleKick(peer, buffer, length);
break;
case NetPacketType.Ping:
this.HandlePing(peer, buffer, length);
break;
case NetPacketType.Pong:
this.HandlePong(peer, buffer, length);
break;
case NetPacketType.Carrier:
this.HandleCarrier(peer, buffer, length);
break;
case NetPacketType.Payload:
this.HandlePayload(peer, buffer, length);
break;
}
}
}
}
}
/// <summary>
/// Registers the given function delegate to the given packet type.
/// </summary>
/// <param name="type">packet type to handle</param>
/// <param name="handler">function delegate designed to handle it</param>
public void Bind(NetPacketType type, MessageDelegate handler)
{
if (handlers.ContainsKey(type))
{
handlers[type] += handler;
}
else
{
handlers.Add(type, handler);
}
}
public static byte[] MakePacket(NetPacketType type, byte[] bs)
{
byte[] ret = new byte[NetPacketHead.HEAD_SIZE + bs.Length];
Array.Copy(BitConverter.GetBytes(NetPacketHead.Version), 0, ret, 0, sizeof(Int32));
Array.Copy(BitConverter.GetBytes((Int32)type), 0, ret, sizeof(Int32), sizeof(Int32));
int Len = bs.Length;
Array.Copy(BitConverter.GetBytes(Len), 0, ret, sizeof(Int32) * 2, sizeof(Int32));
Array.Copy(bs, 0, ret, NetPacketHead.HEAD_SIZE, bs.Length);
return(ret);
}
/// <summary>
/// Invokes the function handler assigned to the specified packet type, using the EventArgs object as parameter.
/// </summary>
/// <param name="type">packet type</param>
/// <param name="peer">sender client</param>
/// <param name="args">parameters for the function (raw data etc.)</param>
protected void HandleEvent(NetPacketType type, NetPeer source, NetEventArgs args)
{
MessageDelegate handler;
if (handlers.TryGetValue(type, out handler))
{
handler(source, args);
}
else
{
if (defaultHandler != null)
{
defaultHandler.Invoke(source, args);
}
}
}
protected void WriteRawPacket(BitStream stream, NetPacketType packetType)
{
WritePacketHeader(stream, packetType);
if (packetType == NetPacketType.DataPacket)
{
var note = AllocNotify();
++NumNotifies;
if (NotifyQueueHead == null)
{
NotifyQueueHead = note;
}
else
{
NotifyQueueTail.NextPacket = note;
}
NotifyQueueTail = note;
note.NextPacket = null;
note.SendTime = Interface.GetCurrentTime();
WritePacketRateInfo(stream, note);
//var start = stream.GetBitPosition();
stream.SetStringTable(StringTable);
//Console.WriteLine("NetConnection {0}: START {1}", NetAddress, GetClassName());
WritePacket(stream, note);
//Console.WriteLine("NetConnection {0}: END {1} - {2} bits", NetAddress, GetClassName(), stream.GetBitPosition() - start);
}
if (SymmetricCipher == null)
{
return;
}
SymmetricCipher.SetupCounter(LastSendSeq, LastSeqRecvd, (uint)packetType, 0U);
stream.HashAndEncrypt(MessageSignatureBytes, PacketHeaderByteSize, SymmetricCipher);
}
protected void WritePacketHeader(BitStream stream, NetPacketType packetType)
{
if (WindowFull() && packetType == NetPacketType.DataPacket)
{
Debugger.Break();
}
var ackByteCount = ((LastSeqRecvd - LastRecvAckAck + 7) >> 3);
if (packetType == NetPacketType.DataPacket)
{
++LastSendSeq;
}
stream.WriteInt((uint)packetType, 2);
stream.WriteInt(LastSendSeq, 5);
stream.WriteFlag(true);
stream.WriteInt(LastSendSeq >> 5, SequenceNumberBitSize - 5);
stream.WriteInt(LastSeqRecvd, AckSequenceNumberBitSize);
stream.WriteInt(0, PacketHeaderPadBits);
stream.WriteRangedU32(ackByteCount, 0, MaxAckByteCount);
var wordCount = (ackByteCount + 3) >> 2;
for (var i = 0U; i < wordCount; ++i)
{
stream.WriteInt(AckMask[i], (byte)(i == wordCount - 1 ? (ackByteCount - (i * 4)) * 8 : 32));
}
var sendDelay = Interface.GetCurrentTime() - LastPacketRecvTime;
if (sendDelay > 2047)
{
sendDelay = 2047;
}
stream.WriteInt((uint)sendDelay >> 3, 8);
if (packetType == NetPacketType.DataPacket)
{
LastSeqRecvdAtSend[LastSendSeq & PacketWindowMask] = LastSeqRecvd;
}
}
internal NetOutboundPacket(NetDeliveryMethod deliveryMethod, NetPacketType type)
{
DeliveryMethod = deliveryMethod;
Type = type;
}
/// <summary>
/// Unregister an external handler for the given packet type.
/// </summary>
/// <param name="type">packet type</param>
/// <param name="handler">function to remove</param>
public static void Unregister(NetPacketType type, MessageDelegate handler)
{
instance.baseServer.Unbind(type, handler);
}
// Params:
// Accept: 0, 0
// Disconnect: InternalReason, UserReason
// Ping: PingSeq, Loss
// Pong: PingSeq, Dropped
internal static int PackProtocol(
byte[] buffer,
NetPacketType type,
byte firstParam,
byte secondParam)
{
buffer[0] = (byte)type;
buffer[1] = firstParam;
buffer[2] = secondParam;
return NetEncoding.PROTOCOL_HEADER_SIZE;
}
public PacketBase(NetPacketType type, int sender)
{
this.type = type;
this.sender = sender;
}
public PacketPlayer(int sender, NetPacketType type, Player player) : base(type, sender)
{
this.player = player;
}
public override void HandlePacket(BinaryReader reader, int whoAmI)
{
NetPacketType type = (NetPacketType)reader.ReadByte();
if (type != NetPacketType.Custom)
{
//Currently only server can said us what we should do
if (whoAmI != 256)
{
return;
}
}
if (type == NetPacketType.EventWasStarted)
{
var name = reader.ReadString();
foreach (WorldEvent it in EventsPool)
{
if (it.GetType().Name == name)
{
ModContent.GetInstance <EventWorld>().StartWorldEvent(it);
break;
}
}
if (ModContent.GetInstance <EventWorld>().CurrentEvent == null)
{
Main.NewText(
$"WARNING! You ether or disable FunMode or you are using outdated version of mod, what haven't an {name} event! Switching to NoSync mode...");
}
ModContent.GetInstance <EventWorld>().CurrentEvent.TimeLeft = reader.ReadInt32();
InvasionType invType = (InvasionType)reader.ReadByte();
if (invType == InvasionType.Invasion)
{
Main.invasionProgressWave = reader.ReadInt32();
Main.invasionSizeStart = reader.ReadInt32();
Main.invasionSize = reader.ReadInt32();
Main.invasionType = reader.ReadInt32();
Main.invasionX = reader.ReadDouble();
Main.invasionProgress = reader.ReadInt32();
}
}
else if (type == NetPacketType.EventWaveUpdated)
{
var name = reader.ReadString();
if (ModContent.GetInstance <EventWorld>().CurrentEvent == null ||
ModContent.GetInstance <EventWorld>().CurrentEvent.GetType().Name != name)
{
//if (ModContent.GetInstance<EventWorld>().CurrentEvent == null)
// Main.NewText($"WARNING! Currently you wont have any executing event, but server send wave update for {name} event!");
if (ModContent.GetInstance <EventWorld>().CurrentEvent.GetType().Name != name)
{
Main.NewText(
$"ERROR! Currently executing event not the same what server sends! Executed event is: {ModContent.GetInstance<EventWorld>().CurrentEvent.GetType().Name}. Server has {name} event!");
ModContent.GetInstance <EventWorld>().CurrentEvent
.EventEnd(ModContent.GetInstance <EventWorld>(), this);
ModContent.GetInstance <EventWorld>().CurrentEvent = null;
}
foreach (WorldEvent it in EventsPool)
{
if (it.GetType().Name == name)
{
ModContent.GetInstance <EventWorld>().StartWorldEvent(it);
break;
}
}
if (ModContent.GetInstance <EventWorld>().CurrentEvent == null)
{
//Main.NewText($"WARNING! You ether or disable FunMode or you are using outdated version of mod, what haven't an {name} event!");
}
}
ModContent.GetInstance <EventWorld>().CurrentEvent.TimeLeft = reader.ReadInt32();
InvasionType invType = (InvasionType)reader.ReadByte();
if (invType == InvasionType.Invasion)
{
Main.invasionProgressWave = reader.ReadInt32();
Main.invasionSizeStart = reader.ReadInt32();
Main.invasionSize = reader.ReadInt32();
Main.invasionType = reader.ReadInt32();
Main.invasionX = reader.ReadDouble();
Main.invasionProgress = reader.ReadInt32();
ModContent.GetInstance <EventWorld>().CurrentEvent.OnWaveChange();
}
}
else if (type == NetPacketType.EventEnded)
{
var name = reader.ReadString();
if (ModContent.GetInstance <EventWorld>().CurrentEvent == null ||
ModContent.GetInstance <EventWorld>().CurrentEvent.GetType().Name != name)
{
if (ModContent.GetInstance <EventWorld>().CurrentEvent == null)
{
Main.NewText(
$"WARNING! Currently you wont have any executing event, but server send event end for {name} event!");
}
if (ModContent.GetInstance <EventWorld>().CurrentEvent.GetType().Name != name)
{
Main.NewText(
$"ERROR! Currently executing event not the same what server sends! Executed event is: {ModContent.GetInstance<EventWorld>().CurrentEvent.GetType().Name}. Server has {name} event!");
ModContent.GetInstance <EventWorld>().CurrentEvent
.EventEnd(ModContent.GetInstance <EventWorld>(), this);
ModContent.GetInstance <EventWorld>().CurrentEvent = null;
}
}
else
{
ModContent.GetInstance <EventWorld>().CurrentEvent
.EventEnd(ModContent.GetInstance <EventWorld>(), this);
ModContent.GetInstance <EventWorld>().CurrentEvent = null;
}
}
else if (type == NetPacketType.Custom)
{
#region Constants
const string lunarSky = "LunarSkies";
const string netSendFix = "NetSend";
#endregion
var eve = reader.ReadString();
if (eve == lunarSky)
{
LunarSkies t = (LunarSkies)reader.ReadByte();
EventPlayer.LunarSky = t;
}
else if (eve == netSendFix)
{
var b = reader.ReadBoolean();
if (b)
{
ModPacket p = GetPacket();
p.Write((byte)NetPacketType.Custom);
p.Write(netSendFix);
p.Write(false);
ModContent.GetInstance <EventWorld>().WriteNetSendData(p);
p.Send(whoAmI);
}
else
{
ModContent.GetInstance <EventWorld>().NetReceive(reader);
}
}
}
}
bool CanLogSend(NetPacketType type)
{
return((type != NetPacketType.AckResponse || NetLogger.LogAcks) &&
type != NetPacketType.MTUTest);
}
bool IsPingPacket(NetPacketType type)
{
return(type == NetPacketType.PingRequest ||
type == NetPacketType.PingResponse);
}
bool IsRemotePacket(NetPacketType type)
{
return(type == NetPacketType.RemoteEvent ||
type == NetPacketType.RemoteFunction ||
type == NetPacketType.RemoteFunctionResponse);
}
public override void OnNetworkReceive(NetPeer peer, NetDataReader reader)
{
NetPacketType type = (NetPacketType)reader.GetUShort();
HandleEvent(type, peer, new NetEventArgs(reader));
}
/// <summary>
/// Register an external handler for the given packet type.
/// </summary>
/// <param name="type">packet type</param>
/// <param name="handler">function to add</param>
public static void Register(NetPacketType type, MessageDelegate handler)
{
instance.baseClient.Bind(type, handler);
}
