public void Test222()
{
try
{
try
{
File.Delete(PacketBufferHelper.GetBufferDbPath());
}
catch { }
var buffer = new RealmPacketBuffer();
var list = new List <byte[]>()
{
"120808020B002F".ToByteArray(),
};
object message = null;
foreach (var bytes in list)
{
message = Message.Unpack(bytes, buffer);
}
}
catch (Exception e)
{
Debugger.Break();
}
}
public void Location__()
{
try
{
try
{
File.Delete(PacketBufferHelper.GetBufferDbPath());
}
catch { }
var buffer = new RealmPacketBuffer();
string text = @"Shovel works with all types of exchanges.
In this example, I've set up exchanges as direct exchanges which use routing keys.
However, if you have fanout exchanges, those will work as well—but you won't indicate a routing key when setting up the shovel for the exchange.
To demonstarate how you can send messages, let's look at the shovels we created for the first exchange that we set up—compose-to-messages-rmq.
This shovel connects to our Compose for RabbitMQ exchange compose-exchange with our messages-rmq exchange in our Messages for RabbitMQ instance.
Ive also created two queues to send messages to: compose - queue in the Compose instance and messages - queue in the Messages for RabbitMQ instance.
Since the shovel is sending messages to the two exchanges, the queues have been bound to the exchanges so that the messages are received and queued up.";
var __a = ChatMessageMT.Create(ProtocolVersion.v3__WeatherExtension, Subscriber.Create("*****@*****.**", SubscriberNetwork.Email), null, null, text);
var __b = ChatMessageMO.Create(ProtocolVersion.v3__WeatherExtension, Subscriber.Create("79153925491", SubscriberNetwork.Mobile), null, null, text);
var a = __a.Pack(56);
var b = __b.Pack(56);
var totalLength = a.Select(x => x.Payload.Length - 8).Sum();
var m1_ = MessageMO.Unpack(b[1].Payload, buffer) as ChatMessageMO;
var m2 = MessageMT.Unpack(a[1].Payload, buffer) as ChatMessageMT;
var m1 = MessageMT.Unpack(a[0].Payload, buffer) as ChatMessageMT;
var m2_ = MessageMO.Unpack(b[0].Payload, buffer) as ChatMessageMO;
var m3 = MessageMT.Unpack(a[2].Payload, buffer) as ChatMessageMT;
var m3_ = MessageMO.Unpack(b[2].Payload, buffer) as ChatMessageMO;
if (!m3.Complete)
{
throw new Exception();
}
if (m3.Text != text)
{
throw new Exception();
}
}
catch (Exception e)
{
}
}
public void FileTest()
{
try
{
File.Delete(PacketBufferHelper.GetBufferDbPath());
}
catch { }
try
{
var file = File.OpenRead(@"C:\Users\Banana\Desktop\file.txt");
var m = ChatMessageMT.Create(
ProtocolVersion.v3__WeatherExtension,
new Subscriber("79999740562", SubscriberNetwork.Mobile), null, null,
"hello image",
lat: 12,
lon: -56,
alt: 561,
file: file,
fileExtension: FileExtension.Jpg,
imageQuality: ImageQuality.Low);
var packets = m.Pack();
string s = packets[0].Payload.ToHexString();
var buffer = new RealmPacketBuffer();
ChatMessageMT message = null;
foreach (var p in packets)
{
message = Message.Unpack(p.Payload, buffer) as ChatMessageMT;
}
if (m.File.Length != message.File.Length)
{
Assert.Fail();
}
var bytes = (message.File as MemoryStream).GetBuffer();
File.WriteAllBytes(@"/Users/banana/Downloads/rockstar-media-test[unpacked].jpg", bytes);
}
catch (Exception e)
{
}
}
/// <summary>
///
/// </summary>
/// <param name="direction"></param>
/// <param name="buffer"></param>
/// <returns></returns>
public static Message Unpack(byte[] buffer, IPacketBuffer packetBuffer = null)
{
if (packetBuffer == null)
{
packetBuffer = new RealmPacketBuffer();
}
using (MemoryStream stream = new MemoryStream(buffer))
{
using (BinaryBitReader reader = new BinaryBitReader((Stream)stream))
{
if (!CheckSignature(reader.ReadByte()))
{
throw new FormatException("Invalid signature!");
}
var direction = reader.ReadBoolean() ? Direction.MO : Direction.MT;
var composite = reader.ReadBoolean() ? Composite.Complex : Composite.Simple;
var version = reader.ReadUInt(3);
var length = (0 + (reader.ReadBoolean() ? ((ushort)0x400) : ((ushort)0)))
+ (reader.ReadBoolean() ? ((ushort)0x200) : ((ushort)0))
+ (reader.ReadBoolean() ? ((ushort)0x100) : ((ushort)0));
int parts = 1;
int part = 0;
int group = 0;
if (composite == Composite.Complex)
{
group = reader.ReadByte();
parts = reader.ReadByte();
part = reader.ReadByte();
}
MessageType messageType = (MessageType)reader.ReadByte();
length += reader.ReadByte();
byte[] payload = reader.ReadBytes(length);
byte sum = reader.ReadByte();
int index = 0;
while (true)
{
if (index >= (stream.Length - 1L))
{
if (sum != 0)
{
throw new FormatException("Invalid checksum!");
}
var types = direction == Direction.MT ? KnownMTTypes : KnownMOTypes;
var type = types.Where(t => t.Key == messageType).FirstOrDefault();
Message message = (Message)Activator.CreateInstance(type.Value, true);
message.Version = (ProtocolVersion)version;
message.Composite = composite;
message.Group = (byte)group;
message.Index = (byte)part;
message.TotalParts = (byte)parts;
message.Payload = payload;
var packet = new Packet()
{
Direction = direction == Direction.MO ? PacketDirection.Outbound : PacketDirection.Inbound,
Index = message.Index,
Group = message.Group,
TotalParts = message.TotalParts,
Payload = message.Payload,
};
packetBuffer.SavePacket(packet);
message.ReadyParts = (byte)packetBuffer.GetPacketCount(message.Group, packet.Direction);
if (message.Complete)
{
var __parts = packetBuffer
.GetPackets(message.Group, packet.Direction)
.OrderBy(x => x.Index)
.Select(x => x.Payload)
.ToList();
message.Payload = ByteArrayHelper.Merge(__parts);
using (MemoryStream stream2 = new MemoryStream(message.Payload))
{
using (BinaryBitReader reader2 = new BinaryBitReader((Stream)stream2))
{
message.unpack(reader2);
}
}
packetBuffer.DeletePackets(message.Group, packet.Direction);
}
return(message);
}
sum -= buffer[index];
index++;
}
}
}
}
public static Legacy_MessageMT Unpack(byte[] buffer, IPacketBuffer partsBuffer = null)
{
using (MemoryStream stream = new MemoryStream(buffer))
{
using (BinaryBitReader reader = new BinaryBitReader((Stream)stream))
{
if (!CheckSignature(reader.ReadByte()))
{
throw new FormatException("Invalid signature!");
}
var group = reader.ReadUInt(16);
var totalParts = reader.ReadUInt(8);
var partIndex = reader.ReadUInt(8);
var payload = reader.ReadAllBytes();
var message = new Legacy_MessageMT()
{
Group = group,
Payload = payload,
Index = partIndex,
TotalParts = totalParts,
};
if (partsBuffer == null)
{
partsBuffer = new RealmPacketBuffer();
}
partsBuffer.SavePacket(new Packet()
{
Index = message.Index,
Group = message.Group,
TotalParts = message.TotalParts,
Payload = message.Payload,
Direction = PacketDirection.Inbound
});
message.ReadyParts = partsBuffer.GetPacketCount(message.Group, PacketDirection.Inbound);
if (message.Complete)
{
var ordered = partsBuffer
.GetPackets(message.Group, PacketDirection.Inbound)
.OrderBy(x => x.Index)
.Select(x => x.Payload)
.ToList();
message.Payload = ByteArrayHelper.Merge(ordered);
partsBuffer.DeletePackets(message.Group, PacketDirection.Inbound);
}
if (message.Complete)
{
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
string text = Encoding.GetEncoding(1251).GetString(message.Payload).Trim();
var parts = text.Split(new string[] { ":" }, 2, StringSplitOptions.RemoveEmptyEntries);
if (parts.Count() < 2)
{
throw new FormatException($"Invalid legacy message format");
}
message.Address = parts[0];
message.RawText = parts[1];
}
return(message);
}
}
}