private byte[] serializeMessage(BinaryMessage m)
{
try
{
MemoryStream ms = new MemoryStream();
StringBuilder str = new StringBuilder();
str
.Append(m.id)
.Append('$')
.Append((int)m.packetType).Append(':')
.Append(m.eventName).Append(':')
.Append(m.command)
.Append('$');
// write header
byte[] header = Encoding.UTF8.GetBytes(str.ToString());
ms.Write(BitConverter.GetBytes(header.Length), 0, 4);
ms.Write(header, 0, header.Length);
// write message
ms.Write(BitConverter.GetBytes(m.message.Length), 0, 4);
ms.Write(m.message, 0, m.message.Length);
// write verification char
ms.Write(Encoding.UTF8.GetBytes("$"), 0, 1);
return(ms.ToArray());
}
catch (Exception) { return(null); }
}
public bool emit(string eventName, string command, byte[] message)
{
if (this.state != NetEventIOClientState.Authenticated)
{
return(false);
}
BinaryMessage m = new BinaryMessage(PacketType.S_binaryEvent, eventName, command, message);
return(this.sendMessage(m));
}
public bool handleBinaryEvent(BinaryMessage m)
{
if (this.state != NetEventIOClientState.Authenticated || m.packetType != PacketType.C_binaryEvent)
{
return(false);
}
OnBinaryMessage listener = null;
try
{
listener = this.binaryMessageListeners[m.eventName];
}
catch (Exception) { return(false); }
if (listener == null)
{
return(false);
}
// emit event
listener(this, m);
return(true);
}
public void Run(bool debug)
{
byte[] message;
bool isBinary;
// get messages
while (this.client.isConnected())
{
if (debug)
{
Console.WriteLine("Esperant a rebre un missatge");
}
if (!this.client.receiveData(out message, out isBinary) || message == null)
{
Console.WriteLine("ERROR REBENT MISSATGE");
this.disconnected();
return;
}
if (isBinary)
{
BinaryMessage binaryMessage = this.parseMessage(message);
if (binaryMessage != null)
{
this.handleBinaryEvent(binaryMessage);
}
continue;
}
Message newMessage;
try
{
newMessage = this.parseMessage(Encoding.UTF8.GetString(message));
}
catch (Exception)
{
continue;
}
if (newMessage != null)
{
if (debug)
{
Console.WriteLine("rebre un missatge " + newMessage.eventName + " " + newMessage.packetType);
}
// switch by packet type on the initialization
switch (newMessage.packetType)
{
case PacketType.C_init:
{
this.handleInit(newMessage);
break;
}
case PacketType.C_authSend:
{
this.handleAuth(newMessage);
break;
}
case PacketType.C_sendEvent:
{
this.handleEvent(newMessage);
break;
}
case PacketType.C_sendEventForCallback:
{
this.handleEventWithCallback(newMessage);
break;
}
case PacketType.C_subscribe:
{
this.handleSubscription(newMessage.eventName);
break;
}
case PacketType.C_unsubscribe:
{
this.handleUnsubscription(newMessage.eventName);
break;
}
case PacketType.C_unsubscribeAll:
{
this.handleUnsubscriptionAll();
break;
}
case PacketType.C_sendCallbackForEvent:
{
this.handleCallbackResponse(newMessage);
break;
}
default:
{
Console.WriteLine("Possible communication error with the client, one message was dropped.");
break;
}
}
}
}
Console.WriteLine("HE ACABAT");
this.disconnected();
}
private bool sendMessage(BinaryMessage bm)
{
byte[] serializedMessage = this.serializeMessage(bm);
return(this.client.sendData(serializedMessage, true));
}
private BinaryMessage parseMessage(byte[] message)
{
try
{
// get the header size
byte[] headerLengthInt = new byte[4];
Array.Copy(message, 0, headerLengthInt, 0, headerLengthInt.Length);
int headerLength = BitConverter.ToInt32(message, 0);
// get the string header
byte[] binaryHeader = new byte[headerLength];
Array.Copy(message, 4, binaryHeader, 0, headerLength);
string header = Encoding.UTF8.GetString(binaryHeader);
// get the message length
byte[] messageLengthInt = new byte[4];
Array.Copy(message, headerLength + 4, messageLengthInt, 0, messageLengthInt.Length);
int messageLength = BitConverter.ToInt32(messageLengthInt, 0);
// get the binary message
byte[] binaryMessage = new byte[messageLength];
Array.Copy(message, headerLength + 8, binaryMessage, 0, binaryMessage.Length);
// initial check
if (header[header.Length - 1] != '$')
{
return(null);
}
// get UUID
int uuidEnd = header.IndexOf('$');
if (uuidEnd == -1)
{
return(null);
}
string uuid = header.Substring(0, uuidEnd);
header = header.Substring(uuidEnd + 1);
// get metadata
int packetInitializationEnd = header.IndexOf('$');
if (packetInitializationEnd == -1)
{
return(null);
}
string[] metadata = header.Substring(0, packetInitializationEnd).Split(':');
if (metadata.Length != 3)
{
return(null);
}
BinaryMessage newMessage = new BinaryMessage();
newMessage.id = uuid;
newMessage.packetType = (PacketType)Int32.Parse(metadata[0]);
newMessage.eventName = metadata[1];
newMessage.command = metadata[2];
newMessage.message = binaryMessage;
return(newMessage);
}
catch (Exception e) { Console.WriteLine("No se pot parsejar " + e.ToString()); return(null); }
}
