internal abstract byte[] SerializeOperationToMessage(byte opCode, Dictionary <byte, object> parameters, PeerBase.EgMessageType messageType, bool encrypt);
internal override byte[] SerializeOperationToMessage(byte opCode, Dictionary <byte, object> parameters, PeerBase.EgMessageType messageType, bool encrypt)
{
byte[] array;
lock (this.SerializeMemStream)
{
this.SerializeMemStream.Position = 0L;
this.SerializeMemStream.SetLength(0L);
if (!encrypt)
{
this.SerializeMemStream.Write(HttpBase3.messageHeader, 0, HttpBase3.messageHeader.Length);
}
Protocol.SerializeOperationRequest(this.SerializeMemStream, opCode, parameters, false);
if (encrypt)
{
byte[] buffer = this.CryptoProvider.Encrypt(this.SerializeMemStream.ToArray());
this.SerializeMemStream.Position = 0L;
this.SerializeMemStream.SetLength(0L);
this.SerializeMemStream.Write(HttpBase3.messageHeader, 0, HttpBase3.messageHeader.Length);
this.SerializeMemStream.Write(buffer, 0, buffer.Length);
}
array = this.SerializeMemStream.ToArray();
}
if (messageType != PeerBase.EgMessageType.Operation)
{
array[HttpBase3.messageHeader.Length - 1] = (byte)messageType;
}
if (encrypt)
{
array[HttpBase3.messageHeader.Length - 1] = (byte)((uint)array[HttpBase3.messageHeader.Length - 1] | 128U);
}
int targetOffset = 1;
Protocol.Serialize(array.Length, array, ref targetOffset);
return(array);
}
internal abstract bool EnqueueOperation(Dictionary <byte, object> parameters, byte opCode, bool sendReliable, byte channelId, bool encrypted, PeerBase.EgMessageType messageType);
internal override byte[] SerializeOperationToMessage(byte opc, Dictionary <byte, object> parameters, PeerBase.EgMessageType messageType, bool encrypt)
{
StreamBuffer serializeMemStream = this.SerializeMemStream;
byte[] array2;
lock (serializeMemStream)
{
this.SerializeMemStream.SetLength(0L);
bool flag = !encrypt;
if (flag)
{
this.SerializeMemStream.Write(this.messageHeader, 0, this.messageHeader.Length);
}
this.protocol.SerializeOperationRequest(this.SerializeMemStream, opc, parameters, false);
if (encrypt)
{
byte[] array = this.CryptoProvider.Encrypt(this.SerializeMemStream.GetBuffer(), 0, (int)this.SerializeMemStream.Length);
this.SerializeMemStream.SetLength(0L);
this.SerializeMemStream.Write(this.messageHeader, 0, this.messageHeader.Length);
this.SerializeMemStream.Write(array, 0, array.Length);
}
array2 = this.SerializeMemStream.ToArray();
}
bool flag2 = messageType != PeerBase.EgMessageType.Operation;
if (flag2)
{
array2[this.messageHeader.Length - 1] = (byte)messageType;
}
if (encrypt)
{
array2[this.messageHeader.Length - 1] = (array2[this.messageHeader.Length - 1] | 128);
}
bool doFraming = this.DoFraming;
if (doFraming)
{
int num = 1;
Protocol.Serialize(array2.Length, array2, ref num);
}
return(array2);
}
internal override bool EnqueueOperation(Dictionary <byte, object> parameters, byte opCode, bool sendReliable, byte channelId, bool encrypted, PeerBase.EgMessageType messageType)
{
if (this.peerConnectionState != PeerBase.ConnectionStateValue.Connected)
{
if (this.debugOut >= DebugLevel.ERROR)
{
this.Listener.DebugReturn(DebugLevel.ERROR, "Cannot send op: Not connected. PeerState: " + (object)this.peerConnectionState);
}
this.Listener.OnStatusChanged(StatusCode.SendError);
return(false);
}
byte[] message = this.SerializeOperationToMessage(opCode, parameters, messageType, encrypted);
if (message == null)
{
return(false);
}
this.outgoingStream.Write(message, 0, message.Length);
return(true);
}
internal override bool EnqueueOperation(Dictionary <byte, object> parameters, byte opCode, bool sendReliable, byte channelId, bool encrypt, PeerBase.EgMessageType messageType)
{
bool flag = this.peerConnectionState != PeerBase.ConnectionStateValue.Connected;
bool result;
if (flag)
{
bool flag2 = base.debugOut >= DebugLevel.ERROR;
if (flag2)
{
base.Listener.DebugReturn(DebugLevel.ERROR, string.Concat(new object[]
{
"Cannot send op: ",
opCode,
"! Not connected. PeerState: ",
this.peerConnectionState
}));
}
base.Listener.OnStatusChanged(StatusCode.SendError);
result = false;
}
else
{
bool flag3 = channelId >= base.ChannelCount;
if (flag3)
{
bool flag4 = base.debugOut >= DebugLevel.ERROR;
if (flag4)
{
base.Listener.DebugReturn(DebugLevel.ERROR, string.Concat(new object[]
{
"Cannot send op: Selected channel (",
channelId,
")>= channelCount (",
base.ChannelCount,
")."
}));
}
base.Listener.OnStatusChanged(StatusCode.SendError);
result = false;
}
else
{
byte[] opMessage = this.SerializeOperationToMessage(opCode, parameters, messageType, encrypt);
result = this.EnqueueMessageAsPayload(sendReliable, opMessage, channelId);
}
}
return(result);
}
internal override bool EnqueueOperation(Dictionary <byte, object> parameters, byte opCode, bool sendReliable, byte channelId, bool encrypt, PeerBase.EgMessageType messageType)
{
if (this.peerConnectionState != PeerBase.ConnectionStateValue.Connected)
{
if (this.debugOut >= DebugLevel.ERROR)
{
this.Listener.DebugReturn(DebugLevel.ERROR, "Cannot send op: " + (object)opCode + "! Not connected. PeerState: " + (object)this.peerConnectionState);
}
this.Listener.OnStatusChanged(StatusCode.SendError);
return(false);
}
if ((int)channelId >= (int)this.ChannelCount)
{
if (this.debugOut >= DebugLevel.ERROR)
{
this.Listener.DebugReturn(DebugLevel.ERROR, "Cannot send op: Selected channel (" + (object)channelId + ")>= channelCount (" + (object)this.ChannelCount + ").");
}
this.Listener.OnStatusChanged(StatusCode.SendError);
return(false);
}
byte[] message = this.SerializeOperationToMessage(opCode, parameters, messageType, encrypt);
return(this.EnqueueMessageAsPayload(sendReliable, message, channelId));
}
/// <summary>
/// Returns the UDP Payload starting with Magic Number for binary protocol
/// </summary>
/// <param name="opc"></param>
/// <param name="parameters"></param>
/// <param name="messageType"></param>
/// <param name="encrypt"></param>
/// <returns></returns>
internal override byte[] SerializeOperationToMessage(byte opc, Dictionary <byte, object> parameters, PeerBase.EgMessageType messageType, bool encrypt)
{
byte[] fullMessageBytes;
lock (base.SerializeMemStream)
{
base.SerializeMemStream.Position = 0L;
base.SerializeMemStream.SetLength(0L);
if (!encrypt)
{
base.SerializeMemStream.Write(messageHeader, 0, messageHeader.Length);
}
Protocol.SerializeOperationRequest(base.SerializeMemStream, opc, parameters, false);
if (encrypt)
{
byte[] opBytes = base.SerializeMemStream.ToArray();
opBytes = base.CryptoProvider.Encrypt(opBytes);
base.SerializeMemStream.Position = 0L;
base.SerializeMemStream.SetLength(0L);
base.SerializeMemStream.Write(messageHeader, 0, messageHeader.Length);
base.SerializeMemStream.Write(opBytes, 0, opBytes.Length);
}
fullMessageBytes = base.SerializeMemStream.ToArray();
}
if (messageType != PeerBase.EgMessageType.Operation)
{
fullMessageBytes[messageHeader.Length - 1] = (byte)messageType;
}
if (encrypt)
{
fullMessageBytes[messageHeader.Length - 1] = (byte)(fullMessageBytes[messageHeader.Length - 1] | 0x80);
}
int offsetForLength = 1;
Protocol.Serialize(fullMessageBytes.Length, fullMessageBytes, ref offsetForLength);
return(fullMessageBytes);
}
internal override bool EnqueueOperation(Dictionary <byte, object> parameters, byte opCode, bool sendReliable, byte channelId, bool encrypt, PeerBase.EgMessageType messageType)
{
if (base.peerConnectionState != PeerBase.ConnectionStateValue.Connected)
{
if (base.debugOut >= DebugLevel.ERROR)
{
base.Listener.DebugReturn(DebugLevel.ERROR, string.Concat("Cannot send op: ", opCode, "! Not connected. PeerState: ", base.peerConnectionState));
}
base.Listener.OnStatusChanged(StatusCode.SendError);
return(false);
}
if (channelId >= base.ChannelCount)
{
if (base.debugOut >= DebugLevel.ERROR)
{
base.Listener.DebugReturn(DebugLevel.ERROR, string.Concat("Cannot send op: Selected channel (", channelId, ")>= channelCount (", base.ChannelCount, ")."));
}
base.Listener.OnStatusChanged(StatusCode.SendError);
return(false);
}
byte[] opBytes = this.SerializeOperationToMessage(opCode, parameters, messageType, encrypt);
return(this.EnqueueMessageAsPayload(sendReliable, opBytes, channelId));
}
internal override bool EnqueueOperation(Dictionary <byte, object> parameters, byte opCode, bool sendReliable, byte channelId, bool encrypted, PeerBase.EgMessageType messageType)
{
if (base.peerConnectionState != PeerBase.ConnectionStateValue.Connected)
{
if (base.debugOut >= DebugLevel.ERROR)
{
base.Listener.DebugReturn(DebugLevel.ERROR, "Cannot send op: Not connected. PeerState: " + base.peerConnectionState);
}
base.Listener.OnStatusChanged(StatusCode.SendError);
return(false);
}
byte[] fullMessageBytes = this.SerializeOperationToMessage(opCode, parameters, messageType, encrypted);
if (fullMessageBytes == null)
{
return(false);
}
this._sendCache.Add(fullMessageBytes);
return(true);
}