public void Deserialize(IoBuffer input, ISerializationContext context)
{
outfit_id = input.GetUInt32();
asset_id = input.GetUInt64();
sale_price = input.GetInt32();
purchase_price = input.GetInt32();
owner_type = input.GetEnum <VMGLOutfitOwner>();
owner_id = input.GetUInt32();
outfit_type = input.Get();
outfit_source = input.GetEnum <VMGLOutfitSource>();
}
public object Deserialize(uint clsid, IoBuffer input, ISerializationContext serializer)
{
var result = new List <sbyte>();
var count = input.GetUInt32();
for (int i = 0; i < count; i++)
{
result.Add((sbyte)input.Get());
}
return(ImmutableList.ToImmutableList(result));
}
public object Deserialize(uint clsid, IoBuffer buffer, ISerializationContext serializer)
{
var result = new Dictionary <uint, bool>();
var count = buffer.GetUInt32();
for (int i = 0; i < count; i++)
{
var key = buffer.GetUInt32();
result.Add(key, buffer.Get() > 0);
}
return(result);
}
public void Deserialize(IoBuffer input, ISerializationContext context)
{
this.User = input.GetString(112, Encoding.ASCII);
this.AriesVersion = input.GetString(80, Encoding.ASCII);
this.Email = input.GetString(40, Encoding.ASCII);
this.Authserv = input.GetString(84, Encoding.ASCII);
this.Product = input.GetUInt16();
this.Unknown = input.Get();
this.ServiceIdent = input.GetString(3, Encoding.ASCII);
this.Unknown2 = input.GetUInt16();
this.Password = input.GetString(32, Encoding.ASCII);
}
public object Deserialize(uint clsid, IoBuffer input, ISerializationContext serializer)
{
var result = new List <byte>();
var iclsid = input.GetUInt32();
var count = input.GetUInt32();
for (int i = 0; i < count; i++)
{
result.Add(input.Get());
}
return(new cTSOGenericData(result.ToArray()));
}
private IoBuffer InsertBytesToNewIoBuffer(IoSession session, IoBuffer buffer)
{
if (_insertByteProbability > _rng.Next(1000))
{
if (log.IsInfoEnabled)
{
log.Info(buffer.GetHexDump());
}
// where to insert bytes ?
int pos = _rng.Next(buffer.Remaining) - 1;
// how many byte to insert ?
int count = _rng.Next(_maxInsertByte - 1) + 1;
IoBuffer newBuff = IoBuffer.Allocate(buffer.Remaining + count);
for (int i = 0; i < pos; i++)
{
newBuff.Put(buffer.Get());
}
for (int i = 0; i < count; i++)
{
newBuff.Put((byte)(_rng.Next(256)));
}
while (buffer.Remaining > 0)
{
newBuff.Put(buffer.Get());
}
newBuff.Flip();
if (log.IsInfoEnabled)
{
log.Info("Inserted " + count + " bytes.");
log.Info(newBuff.GetHexDump());
}
return(newBuff);
}
return(null);
}
public IDecodingState Decode(IoBuffer input, IProtocolDecoderOutput output)
{
Boolean found = false;
Boolean finished = false;
while (input.HasRemaining)
{
Byte b = input.Get();
if (!_hasCR)
{
if (b == CR)
{
_hasCR = true;
}
else
{
if (b == LF)
{
found = true;
}
else
{
input.Position = input.Position - 1;
found = false;
}
finished = true;
break;
}
}
else
{
if (b == LF)
{
found = true;
finished = true;
break;
}
throw new ProtocolDecoderException("Expected LF after CR but was: " + (b & 0xff));
}
}
if (finished)
{
_hasCR = false;
return(FinishDecode(found, output));
}
return(this);
}
public override void Deserialize(IoBuffer input, ISerializationContext context)
{
var dataLen = input.GetInt32(); //TODO: limits? 4MB is probably reasonable.
var data = new byte[dataLen];
input.Get(data, 0, dataLen);
using (var mem = new MemoryStream(data))
{
using (var reader = new BinaryReader(mem))
{
Tuning = new DynamicTuning(reader);
}
}
}
public override void MessageReceived(IoSession session, Object message)
{
IoBuffer buffer = (IoBuffer)message;
Byte[] data = new Byte[buffer.Remaining];
buffer.Get(data, 0, data.Length);
Object sync = session.GetAttribute("lock");
lock (sync)
{
StringBuilder sb = session.GetAttribute <StringBuilder>("received");
sb.Append(Encoding.ASCII.GetString(data));
Monitor.PulseAll(sync);
}
}
protected override bool DoDecode(IoSession session, IoBuffer buffer, IProtocolDecoderOutput output)
{
if (buffer.Remaining < 8)
{
return(false);
}
/**
* We expect aries, voltron or electron packets
*/
var startPosition = buffer.Position;
buffer.Order = ByteOrder.LittleEndian;
uint packetType = buffer.GetUInt32(); //currently unused
uint payloadSize = buffer.GetUInt32();
if (buffer.Remaining < payloadSize)
{
/** Not all here yet **/
buffer.Position = startPosition;
return(false);
}
var type = (VMNetMessageType)buffer.Get();
var data = new List <byte>();
for (int i = 0; i < payloadSize - 1; i++)
{
data.Add(buffer.Get());
}
var packet = new VMNetMessage(type, data.ToArray());
output.Write(packet);
return(true);
}
public override void Deserialize(IoBuffer input, ISerializationContext context)
{
this.SendingAvatarID = input.GetUInt32();
this.RequestTypeID = input.GetUInt32();
var bodySize = input.GetUInt32();
var bodyBytes = new byte[bodySize];
input.Get(bodyBytes, 0, (int)bodySize);
this.Body = bodyBytes;
var bodyBuffer = IoBuffer.Wrap(bodyBytes);
var bodyType = bodyBuffer.GetUInt32();
this.Body = context.ModelSerializer.Deserialize(bodyType, bodyBuffer, context);
}
static void Main(string[] args)
{
if (args.Length != 2)
{
Console.WriteLine(typeof(Program).FullName + " <hostname> <port>");
return;
}
// Create TCP/IP connector.
AsyncSocketConnector connector = new AsyncSocketConnector();
// Set connect timeout.
connector.ConnectTimeoutInMillis = 30 * 1000L;
// Set reader idle time to 10 seconds.
// sessionIdle(...) method will be invoked when no data is read
// for 10 seconds.
connector.SessionOpened += (s, e) => e.Session.Config.SetIdleTime(IdleStatus.ReaderIdle, 10);
// Print out total number of bytes read from the remote peer.
connector.SessionClosed += (s, e) => Console.WriteLine("Total " + e.Session.ReadBytes + " byte(s)");
connector.SessionIdle += (s, e) =>
{
if (e.IdleStatus == IdleStatus.ReaderIdle)
{
e.Session.Close(true);
}
};
connector.MessageReceived += (s, e) =>
{
IoBuffer buf = (IoBuffer)e.Message;
while (buf.HasRemaining)
{
Console.Write((Char)buf.Get());
}
};
// Start communication.
IConnectFuture cf = connector.Connect(new IPEndPoint(Dns.GetHostEntry(args[0]).AddressList[3], Int32.Parse(args[1])));
// Wait for the connection attempt to be finished.
cf.Await();
cf.Session.CloseFuture.Await();
connector.Dispose();
}
public MessageDecoderResult Decode(IoSession session, IoBuffer input, IProtocolDecoderOutput output)
{
int totalLen = input.GetInt32();
int len = totalLen - 4;
if (input.Remaining < len)
{
return(MessageDecoderResult.NeedData);
}
byte[] jsonBuffer = new byte[len];
input.Get(jsonBuffer, 0, len);
string msg = System.Text.Encoding.UTF8.GetString(jsonBuffer);
output.Write(msg);
return(MessageDecoderResult.OK);
}
private static FileInfo CreateLargeFile()
{
IoBuffer buffer = IoBuffer.Allocate(FILE_SIZE);
for (Int32 i = 0; i < FILE_SIZE / 4; i++)
{
buffer.PutInt32(i);
}
buffer.Flip();
String path = Path.GetTempFileName();
Byte[] data = new Byte[buffer.Remaining];
buffer.Get(data, 0, data.Length);
File.WriteAllBytes(path, data);
return(new FileInfo(path));
}
public override void Deserialize(IoBuffer input, ISerializationContext context)
{
this.MajorVersion = input.GetUInt16();
this.MinorVersion = input.GetUInt16();
this.PointVersion = input.GetUInt16();
this.ArtVersion = input.GetUInt16();
this.Timestamp = input.GetUInt64();
this.NumberOfAttempts = input.Get();
this.LastExitCode = input.Get();
this.LastFailureType = input.Get();
this.FailureCount = input.Get();
this.IsRunning = input.Get();
this.IsReLogging = input.Get();
}
public override void FilterWrite(INextFilter nextFilter, IoSession session, IWriteRequest writeRequest)
{
_counter++;
IoBuffer buf = writeRequest.Message as IoBuffer;
if (buf == null)
{
throw new AssertFailedException("Wrong message type");
}
if (_counter == 3)
{
Assert.AreEqual(1, buf.Limit);
Assert.AreEqual(0, buf.Get());
}
else
{
Assert.AreEqual(10, buf.Limit);
}
}
public MessageDecoderResult Decode(IoSession session, IoBuffer input, IProtocolDecoderOutput output)
{
int limit = input.Limit;
int position = input.Position;
var len = input.GetInt32();
var version = input.Get();
input.Position = position;
input.Limit = input.Position + len;
var buffer = input.Slice();
input.Position = input.Limit;
input.Limit = limit;
var message = DoDecode(version.ToEnum <MessageVersion>(), buffer);
if (message != null)
{
output.Write(message);
}
return(MessageDecoderResult.OK);
}
public void Deserialize(IoBuffer input, ISerializationContext context)
{
var count = input.GetUInt32();
Items = new List <Top100Entry>((int)count);
for (var i = 0; i < count; i++)
{
var item = new Top100Entry();
item.Rank = input.Get();
var hasValue = input.GetBool();
if (hasValue)
{
item.TargetId = input.GetUInt32();
item.TargetName = input.GetPascalVLCString();
}
Items.Add(item);
}
}
public override void Deserialize(IoBuffer input, ISerializationContext context)
{
Type = input.GetEnum <MailResponseType>();
var numMessages = input.GetInt32();
Messages = new MessageItem[numMessages];
for (int j = 0; j < numMessages; j++)
{
var length = input.GetInt32();
var dat = new byte[length];
for (int i = 0; i < length; i++)
{
dat[i] = input.Get();
}
using (var str = new MemoryStream(dat))
{
Messages[j] = new MessageItem(str);
}
}
}
public IDecodingState Decode(IoBuffer input, IProtocolDecoderOutput output)
{
Int32 beginPos = input.Position;
Int32 limit = input.Limit;
for (Int32 i = beginPos; i < limit; i++)
{
Byte b = input.Get(i);
if (!CanSkip(b))
{
input.Position = i;
Int32 answer = _skippedBytes;
_skippedBytes = 0;
return(FinishDecode(answer));
}
_skippedBytes++;
}
input.Position = limit;
return(this);
}
public override void Deserialize(IoBuffer input, ISerializationContext context)
{
Type = input.GetEnum <MailRequestType>();
if (Type == MailRequestType.SEND)
{
var length = input.GetInt32();
var dat = new byte[length];
for (int i = 0; i < length; i++)
{
dat[i] = input.Get();
}
using (var str = new MemoryStream(dat))
{
Item = new MessageItem(str);
}
}
else
{
TimestampID = input.GetInt64();
}
}
private void DecodeVoltronStylePackets(IoBuffer buffer, ref uint payloadSize, IProtocolDecoderOutput output, Func <ushort, Type> typeResolver)
{
while (payloadSize > 0)
{
/** Voltron packet **/
buffer.Order = ByteOrder.BigEndian;
ushort type = buffer.GetUInt16();
uint innerPayloadSize = buffer.GetUInt32() - 6;
byte[] data = new byte[(int)innerPayloadSize];
buffer.Get(data, 0, (int)innerPayloadSize);
var packetClass = typeResolver(type);
if (packetClass != null)
{
IoBufferDeserializable packet = (IoBufferDeserializable)Activator.CreateInstance(packetClass);
packet.Deserialize(IoBuffer.Wrap(data), Context);
output.Write(packet);
}
payloadSize -= innerPayloadSize + 6;
}
}
public MessageDecoderResult Decodable(IoSession session, IoBuffer input)
{
if (input.Remaining < MIN_PACKET_LENGTH)
{
return(MessageDecoderResult.NeedData);
}
var symbol = input.GetArray(2);
if (DataPacket.True(symbol))
{
input.Skip(1);
var len = input.Get();
input.Rewind();
if (len > input.Remaining)
{
return(MessageDecoderResult.NeedData);
}
}
else if (!CtlPacket.True(symbol))
{
return(MessageDecoderResult.NotOK);
}
return(MessageDecoderResult.OK);
}
public override void MessageSent(INextFilter nextFilter, IoSession session, IWriteRequest writeRequest)
{
IVoltronPacket voltronPacket = writeRequest.OriginalRequest.Message as IVoltronPacket;
if (voltronPacket != null)
{
var voltronBuffer = IoBuffer.Allocate(512);
voltronBuffer.Order = ByteOrder.BigEndian;
voltronBuffer.AutoExpand = true;
voltronPacket.Serialize(voltronBuffer, Context);
voltronBuffer.Flip();
var byteArray = new byte[voltronBuffer.Remaining];
voltronBuffer.Get(byteArray, 0, voltronBuffer.Remaining);
PacketLogger.OnPacket(new Packet
{
Data = byteArray,
Type = PacketType.VOLTRON,
SubType = voltronPacket.GetPacketType().GetPacketCode(),
Direction = PacketDirection.OUTPUT
});
nextFilter.MessageSent(session, writeRequest);
return;
}
IAriesPacket ariesPacket = writeRequest.OriginalRequest.Message as IAriesPacket;
if (ariesPacket != null)
{
IoBuffer ariesBuffer = IoBuffer.Allocate(128);
ariesBuffer.AutoExpand = true;
ariesBuffer.Order = ByteOrder.LittleEndian;
ariesPacket.Serialize(ariesBuffer, Context);
ariesBuffer.Flip();
var byteArray = new byte[ariesBuffer.Remaining];
ariesBuffer.Get(byteArray, 0, ariesBuffer.Remaining);
PacketLogger.OnPacket(new Packet
{
Data = byteArray,
Type = PacketType.ARIES,
SubType = ariesPacket.GetPacketType().GetPacketCode(),
Direction = PacketDirection.OUTPUT
});
nextFilter.MessageSent(session, writeRequest);
return;
}
IoBuffer buffer = writeRequest.Message as IoBuffer;
if (buffer == null)
{
nextFilter.MessageSent(session, writeRequest);
return;
}
TryParseAriesFrame(buffer, PacketDirection.OUTPUT);
nextFilter.MessageSent(session, writeRequest);
}
private void TryParseAriesFrame(IoBuffer buffer, PacketDirection direction)
{
buffer.Rewind();
if (buffer.Remaining < 12)
{
return;
}
buffer.Order = ByteOrder.LittleEndian;
uint packetType = buffer.GetUInt32();
uint timestamp = buffer.GetUInt32();
uint payloadSize = buffer.GetUInt32();
if (buffer.Remaining < payloadSize)
{
buffer.Skip(-12);
return;
}
while (payloadSize > 0)
{
if (packetType == 0)
{
/** Voltron packet **/
buffer.Order = ByteOrder.BigEndian;
ushort voltronType = buffer.GetUInt16();
uint voltronPayloadSize = buffer.GetUInt32() - 6;
byte[] data = new byte[(int)voltronPayloadSize];
buffer.Get(data, 0, (int)voltronPayloadSize);
PacketLogger.OnPacket(new Packet
{
Data = data,
Type = PacketType.VOLTRON,
SubType = voltronType,
Direction = direction
});
payloadSize -= voltronPayloadSize + 6;
}
else
{
byte[] data = new byte[(int)payloadSize];
buffer.Get(data, 0, (int)payloadSize);
PacketLogger.OnPacket(new Packet
{
Data = data,
Type = PacketType.ARIES,
SubType = packetType,
Direction = direction
});
payloadSize = 0;
}
}
buffer.Rewind();
}
public static bool GetBool(this IoBuffer buffer)
{
return(buffer.Get() == 1 ? true : false);
}
private void DecodeNormal(Context ctx, IoSession session, IoBuffer input, IProtocolDecoderOutput output)
{
Int32 matchCount = ctx.MatchCount;
// Try to find a match
Int32 oldPos = input.Position, oldLimit = input.Limit;
while (input.HasRemaining)
{
Byte b = input.Get();
if (_delimBuf[matchCount] == b)
{
matchCount++;
if (matchCount == _delimBuf.Length)
{
// Found a match.
Int32 pos = input.Position;
input.Limit = pos;
input.Position = oldPos;
ctx.Append(input);
input.Limit = oldLimit;
input.Position = pos;
if (ctx.OverflowPosition == 0)
{
IoBuffer buf = ctx.Buffer;
buf.Flip();
buf.Limit -= matchCount;
ArraySegment <Byte> bytes = buf.GetRemaining();
try
{
String str = _encoding.GetString(bytes.Array, bytes.Offset, bytes.Count);
WriteText(session, str, output);
}
finally
{
buf.Clear();
}
}
else
{
Int32 overflowPosition = ctx.OverflowPosition;
ctx.Reset();
throw new RecoverableProtocolDecoderException("Line is too long: " + overflowPosition);
}
oldPos = pos;
matchCount = 0;
}
}
else
{
input.Position = Math.Max(0, input.Position - matchCount);
matchCount = 0;
}
}
// Put remainder to buf.
input.Position = oldPos;
ctx.Append(input);
ctx.MatchCount = matchCount;
}
private void DecodeAuto(Context ctx, IoSession session, IoBuffer input, IProtocolDecoderOutput output)
{
Int32 matchCount = ctx.MatchCount;
// Try to find a match
Int32 oldPos = input.Position, oldLimit = input.Limit;
while (input.HasRemaining)
{
Byte b = input.Get();
Boolean matched = false;
switch (b)
{
case 0x0d: // \r
// Might be Mac, but we don't auto-detect Mac EOL
// to avoid confusion.
matchCount++;
break;
case 0x0a: // \n
// UNIX
matchCount++;
matched = true;
break;
default:
matchCount = 0;
break;
}
if (matched)
{
// Found a match.
Int32 pos = input.Position;
input.Limit = pos;
input.Position = oldPos;
ctx.Append(input);
input.Limit = oldLimit;
input.Position = pos;
if (ctx.OverflowPosition == 0)
{
IoBuffer buf = ctx.Buffer;
buf.Flip();
buf.Limit -= matchCount;
ArraySegment <Byte> bytes = buf.GetRemaining();
try
{
String str = _encoding.GetString(bytes.Array, bytes.Offset, bytes.Count);
WriteText(session, str, output);
}
finally
{
buf.Clear();
}
}
else
{
Int32 overflowPosition = ctx.OverflowPosition;
ctx.Reset();
throw new RecoverableProtocolDecoderException("Line is too long: " + overflowPosition);
}
oldPos = pos;
matchCount = 0;
}
}
// Put remainder to buf.
input.Position = oldPos;
ctx.Append(input);
ctx.MatchCount = matchCount;
}
public object Deserialize(uint clsid, IoBuffer input, ISerializationContext serializer)
{
var byteValue = input.Get();
return(byteValue == 0x01 ? true : false);
}
private void ManipulateIoBuffer(IoSession session, IoBuffer buffer)
{
if ((buffer.Remaining > 0) && (_removeByteProbability > _rng.Next(1000)))
{
if (log.IsInfoEnabled)
{
log.Info(buffer.GetHexDump());
}
// where to remove bytes ?
int pos = _rng.Next(buffer.Remaining);
// how many byte to remove ?
int count = _rng.Next(buffer.Remaining - pos) + 1;
if (count == buffer.Remaining)
{
count = buffer.Remaining - 1;
}
IoBuffer newBuff = IoBuffer.Allocate(buffer.Remaining - count);
for (int i = 0; i < pos; i++)
{
newBuff.Put(buffer.Get());
}
buffer.Skip(count); // hole
while (newBuff.Remaining > 0)
{
newBuff.Put(buffer.Get());
}
newBuff.Flip();
// copy the new buffer in the old one
buffer.Rewind();
buffer.Put(newBuff);
buffer.Flip();
if (log.IsInfoEnabled)
{
log.Info("Removed " + count + " bytes at position " + pos + ".");
log.Info(buffer.GetHexDump());
}
}
if ((buffer.Remaining > 0) && (_changeByteProbability > _rng.Next(1000)))
{
if (log.IsInfoEnabled)
{
log.Info(buffer.GetHexDump());
}
// how many byte to change ?
int count = _rng.Next(buffer.Remaining - 1) + 1;
byte[] values = new byte[count];
_rng.NextBytes(values);
for (int i = 0; i < values.Length; i++)
{
int pos = _rng.Next(buffer.Remaining);
buffer.Put(pos, values[i]);
}
if (log.IsInfoEnabled)
{
log.Info("Modified " + count + " bytes.");
log.Info(buffer.GetHexDump());
}
}
}
