private bool HandleInternalMessage(Peer toPassTo, LidgrenTransferPacket packet)
{
if (packet.isEncrypted)
{
if (toPassTo.EncryptionRegister.HasKey(packet.EncryptionMethodByte))
{
if (!packet.Decrypt(toPassTo.EncryptionRegister[packet.EncryptionMethodByte]))
{
ClassLogger.LogError("Failed to decrypt package from Peer ID: "
+ toPassTo.UniqueConnectionId + " with EncryptionByte: " + packet.EncryptionMethodByte);
return(false);
}
}
}
PacketBase deserializedPacketBase = InternalPacketConstructor(packet);
switch (packet.OperationType)
{
case Packet.OperationType.Request:
return(this.ProcessInternalRequest((InternalPacketCode)packet.PacketCode, deserializedPacketBase, toPassTo));
case Packet.OperationType.Response:
return(this.ProcessInternalResponse((InternalPacketCode)packet.PacketCode, deserializedPacketBase, toPassTo));
case Packet.OperationType.Event:
throw new LoggableException("GladNet currently does not support internal events.", null, LogType.Error);
default:
return(false);
}
}
//This does not need to be in a unity peer. A Unity peer cannot broadcast.
#if !UNITYDEBUG && !UNITYRELEASE
//TODO: One day we will need to optimize the ability to broadcast messages as we'll have to convert to a NetConnection list at some point when it's being called externally through
//the exposed API of GladNet.
protected void BroadcastEvent(IList <Peer> connections, PacketBase packet, byte packetCode, Packet.DeliveryMethod deliveryMethod, byte encrypt = EncryptionBase.NoEncryptionByte, int channel = 0)
{
try
{
LidgrenTransferPacket transferPacket = new LidgrenTransferPacket(Packet.OperationType.Event, packet.SerializerKey, packetCode, packet.Serialize());
if (encrypt != EncryptionBase.NoEncryptionByte)
{
EncryptionLidgrenPackage(encrypt, transferPacket);
}
//TODO: Encryption because it's ready
byte[] bytes = Serializer <GladNetProtobufNetSerializer> .Instance.Serialize(transferPacket);
//Inefficient O(n) casting to a NetConnection list. Not good.
this.InternalNetConnection.Peer.SendMessage(false, connections.Select(x => x.InternalNetConnection).ToList(), bytes, Packet.LidgrenDeliveryMethodConvert(deliveryMethod), channel);
}
catch (LoggableException e)
{
throw;
}
catch (Exception e)
{
throw new LoggableException("Exception occured in serialization of packet.", e, LogType.Error);
}
}
public virtual Packet.SendResult SendMessage(Packet.OperationType type, PacketBase packet, byte packetCode, Packet.DeliveryMethod deliveryMethod, int channel = 0, byte encrypt = EncryptionBase.NoEncryptionByte, bool isInternal = false)
#endif
{
try
{
LidgrenTransferPacket transferPacket = new LidgrenTransferPacket(type, packet.SerializerKey, packetCode, packet.Serialize());
if (encrypt != EncryptionBase.NoEncryptionByte)
{
EncryptionLidgrenPackage(encrypt, transferPacket);
}
//TODO: encryption because it's ready
byte[] bytes = Serializer <GladNetProtobufNetSerializer> .Instance.Serialize(transferPacket);
return((Packet.SendResult) this.InternalNetConnection.SendMessage(isInternal, bytes, Packet.LidgrenDeliveryMethodConvert(deliveryMethod), channel));
}
catch (LoggableException e)
{
throw;
}
catch (Exception e)
{
throw new LoggableException("Exception occured in serialization of packet.", e, LogType.Error);
}
}
public MessageInfo(LidgrenTransferPacket lidgrenPacket, NetDeliveryMethod delivery)
#endif
{
if (lidgrenPacket == null)
{
throw new ArgumentException("In Ctor of MessageInfo a null packet was passed.");
}
deliveryMethod = delivery;
this.EncryptionMethodType = lidgrenPacket.EncryptionMethodByte;
this.wasEncrypted = lidgrenPacket.wasEncrypted;
}
private void EncryptionLidgrenPackage(byte encrypt, LidgrenTransferPacket packet)
{
if (EncryptionRegister.HasKey(encrypt))
{
packet.Encrypt(EncryptionRegister[encrypt]);
}
else
{
throw new LoggableException("Failed to encrypt package for Peer ID: "
+ this.UniqueConnectionId + " With encryption ByteType: " + encrypt, null, LogType.Error);
}
}
public virtual bool DispatchMessage(Peer toPassTo, NetIncomingMessage msg, bool isInternal)
{
if (msg == null)
{
throw new LoggableException("When dispatched NetBuffer was found to be null.", null, LogType.Error);
}
LidgrenTransferPacket packet = this.BuildTransferPacket(msg);
if (toPassTo == null)
{
return(false);
}
if (!this.SerializerRegister.HasKey(packet.SerializerKey))
{
ClassLogger.LogError("Recieved a packet that cannot be handled due to not having a serializer registered with byte code: " + packet.SerializerKey);
return(false);
}
if (packet == null)
{
ClassLogger.LogError("Lidgren packet built to null.");
return(false);
}
if (toPassTo == null)
{
ClassLogger.LogError("When attempted to dispatch the Peer passed was found to be null.");
return(false);
}
#if UNITYDEBUG || DEBUG
this.ClassLogger.LogDebug("About to handle packet. Encrypted: " + packet.isEncrypted.ToString() + " EncryptionCode: " + packet.EncryptionMethodByte);
#endif
if (!isInternal)
{
if (packet.isEncrypted)
{
return(DispatchEncryptedMessage(toPassTo, packet, msg.DeliveryMethod));
}
else
{
return(Dispatch(toPassTo, packet, msg.DeliveryMethod));
}
}
else
{
return(HandleInternalMessage(toPassTo, packet));
}
}
private bool DispatchEncryptedMessage(Peer toPassTo, LidgrenTransferPacket packet, NetDeliveryMethod method)
{
if (!toPassTo.EncryptionRegister.HasKey(packet.EncryptionMethodByte))
{
ClassLogger.LogError("Failed to decrypt packet. Client requested unregistered method: " + packet.EncryptionMethodByte);
return(false);
}
try
{
switch (packet.OperationType)
{
case Packet.OperationType.Event:
EventPackage ep = this.GeneratePackage <EventPackage>(packet, toPassTo.EncryptionRegister[packet.EncryptionMethodByte]);
if (ep != null)
{
toPassTo.PackageRecieve(ep, new MessageInfo(packet, method));
}
return(true);
case Packet.OperationType.Request:
RequestPackage rqp = this.GeneratePackage <RequestPackage>(packet, toPassTo.EncryptionRegister[packet.EncryptionMethodByte]);
if (rqp != null)
{
toPassTo.PackageRecieve(rqp, new MessageInfo(packet, method));
}
return(true);
case Packet.OperationType.Response:
ResponsePackage rp = this.GeneratePackage <ResponsePackage>(packet, toPassTo.EncryptionRegister[packet.EncryptionMethodByte]);
if (rp != null)
{
toPassTo.PackageRecieve(rp, new MessageInfo(packet, method));
}
return(true);
default:
return(false);
}
}
catch (LoggableException e)
{
ClassLogger.LogError(e.Message + e.InnerException != null ? " Inner: " + e.InnerException : "");
return(false);
}
}
internal MessageInfo(LidgrenTransferPacket lidgrenPacket, NetDeliveryMethod delivery)
