public void TestBasicBuffering()
{
DummySession sess = new DummySession();
sess.FilterChain.AddFirst("peer", new DummyFilter());
sess.FilterChain.AddFirst("logger", new LoggingFilter());
BufferedWriteFilter bFilter = new BufferedWriteFilter(10);
sess.FilterChain.AddLast("buffer", bFilter);
IoBuffer data = IoBuffer.Allocate(1);
for (byte i = 0; i < 20; i++)
{
data.Put((byte)(0x30 + i));
data.Flip();
sess.Write(data);
data.Clear();
}
// Add one more byte to overflow the final buffer
data.Put((byte)0);
data.Flip();
sess.Write(data);
// Flush the final byte
bFilter.Flush(sess);
sess.Close(true);
}
public static void PutPascalVLCString(this IoBuffer buffer, String value)
{
byte[] encode = null;
long strlen = 0;
if (value != null)
{
encode = Encoding.UTF8.GetBytes(value);
strlen = encode.Length;
}
bool write = strlen > 0;
bool first = true;
while (strlen > 0 || first)
{
buffer.Put((byte)(((strlen > 127) ? (uint)128 : 0) | (strlen & 127)));
strlen >>= 7;
first = false;
}
if (write)
{
buffer.Put(encode);
}
}
public override void Serialize(IoBuffer output, ISerializationContext context)
{
output.Skip(37);
output.PutPascalVLCString(Name);
output.PutPascalVLCString(Description);
output.Put(Gender == Gender.FEMALE ? (byte)0x01 : (byte)0x00);
switch (SkinTone)
{
case SkinTone.LIGHT:
output.Put(0x00);
break;
case SkinTone.MEDIUM:
output.Put(0x01);
break;
case SkinTone.DARK:
output.Put(0x02);
break;
}
output.PutUInt32(HeadOutfitId);
output.Skip(4);//Unknown
output.PutUInt32(BodyOutfitId);
}
public static void PutPascalVLCString(this IoBuffer buffer, string value)
{
long strlen = 0;
if (value != null)
{
strlen = value.Length;
}
bool write = strlen > 0;
bool first = true;
while (strlen > 0 || first)
{
buffer.Put((byte)(((strlen > 127) ? 128 : 0) | (strlen & 127)));
strlen >>= 7;
first = false;
}
if (write)
{
foreach (char ch in value.ToCharArray())
{
buffer.Put((byte)ch);
}
}
}
public IDecodingState Decode(IoBuffer input, IProtocolDecoderOutput output)
{
if (_buffer == null)
{
if (input.Remaining >= _length)
{
Int32 limit = input.Limit;
input.Limit = input.Position + _length;
IoBuffer product = input.Slice();
input.Position = input.Position + _length;
input.Limit = limit;
return(FinishDecode(product, output));
}
_buffer = IoBuffer.Allocate(_length);
_buffer.Put(input);
return(this);
}
if (input.Remaining >= _length - _buffer.Position)
{
Int32 limit = input.Limit;
input.Limit = input.Position + _length - _buffer.Position;
_buffer.Put(input);
input.Limit = limit;
IoBuffer product = _buffer;
_buffer = null;
return(FinishDecode(product.Flip(), output));
}
_buffer.Put(input);
return(this);
}
public static void PutPascalString(this IoBuffer buffer, string value)
{
long strlen = 0;
if (value != null)
{
strlen = value.Length;
}
byte len1 = (byte)((strlen >> 24) | 0x80);
byte len2 = (byte)((strlen >> 16) & 0xFF);
byte len3 = (byte)((strlen >> 8) & 0xFF);
byte len4 = (byte)(strlen & 0xFF);
buffer.Put(len1);
buffer.Put(len2);
buffer.Put(len3);
buffer.Put(len4);
if (strlen > 0)
{
foreach (char ch in value.ToCharArray())
{
buffer.Put((byte)ch);
}
}
}
protected override void Fill(IoBuffer buffer)
{
buffer.Put(Length);
buffer.Put(FRAME_SOURCE_ADDR);
buffer.Put(Protocol);
buffer.Put(FRAME_SEQUENCE_VALUE);
this.FillData(buffer);
}
public override void Serialize(IoBuffer output, ISerializationContext context)
{
output.Put(EchoRequested ? (byte)1 : (byte)0);
PutSender(output, Sender);
output.Put(Badge);
output.Put(Alertable);
output.PutPascalString(Message);
}
public override void Serialize(IoBuffer output, ISerializationContext context)
{
output.PutPascalString(SenderID);
output.PutPascalString(SenderAccount);
output.Put(Badge);
output.Put(IsAlertable);
output.PutPascalString(Subject);
output.PutPascalString(Message);
}
public IDecodingState Decode(IoBuffer input, IProtocolDecoderOutput output)
{
Int32 terminatorPos = input.IndexOf(_terminator);
if (terminatorPos >= 0)
{
Int32 limit = input.Limit;
IoBuffer product;
if (input.Position < terminatorPos)
{
input.Limit = terminatorPos;
if (_buffer == null)
{
product = input.Slice();
}
else
{
_buffer.Put(input);
product = _buffer.Flip();
_buffer = null;
}
input.Limit = limit;
}
else
{
// When input contained only terminator rather than actual data...
if (_buffer == null)
{
product = IoBuffer.Allocate(0);
}
else
{
product = _buffer.Flip();
_buffer = null;
}
}
input.Position = terminatorPos + 1;
return(FinishDecode(product, output));
}
if (_buffer == null)
{
_buffer = IoBuffer.Allocate(input.Remaining);
_buffer.AutoExpand = true;
}
_buffer.Put(input);
return(this);
}
public override void Serialize(IoBuffer output, ISerializationContext context)
{
output.PutUInt32(SendingAvatarID);
PutSender(output, Sender);
output.Put(Badge);
output.Put(IsAlertable);
if (Body != null)
{
var bodyBytes = context.ModelSerializer.SerializeBuffer(Body, context, true);
output.PutUInt32((uint)bodyBytes.Remaining);
output.Put(bodyBytes);
}
}
public override void Serialize(IoBuffer output, ISerializationContext context)
{
using (var mem = new MemoryStream())
{
using (var writer = new BinaryWriter(mem))
{
Tuning.SerializeInto(writer);
var result = mem.ToArray();
output.PutInt32(result.Length);
output.Put(result, 0, result.Length);
}
}
output.PutInt32(ObjectUpgrades.Length);
output.Put(ObjectUpgrades, 0, ObjectUpgrades.Length);
}
private void Write(IoSession session, IoBuffer data, IoBuffer buf)
{
try
{
Int32 len = data.Remaining;
if (len >= buf.Capacity)
{
/*
* If the request length exceeds the size of the output buffer,
* flush the output buffer and then write the data directly.
*/
INextFilter nextFilter = session.FilterChain.GetNextFilter(this);
InternalFlush(nextFilter, session, buf);
nextFilter.FilterWrite(session, new DefaultWriteRequest(data));
return;
}
if (len > (buf.Limit - buf.Position))
{
InternalFlush(session.FilterChain.GetNextFilter(this), session, buf);
}
lock (buf)
{
buf.Put(data);
}
}
catch (Exception e)
{
session.FilterChain.FireExceptionCaught(e);
}
}
public void SendMsg()
{
//lock (this)
{
while (m_sendMsgs.Count > 0)
{
MessageBody msg = m_sendMsgs.Dequeue();
if (msg != null)
{
m_sendBuffer.Clear();
Array.Clear(m_sendData, 0, m_sendData.Length);
int len = CPacket.HEADER_TYPE_BYTES + msg.data.Length;
m_sendBuffer.PutInt32(len);
m_sendBuffer.PutInt16((short)msg.type);
m_sendBuffer.Put(msg.data);
m_sendBuffer.Flip();
m_sendBuffer.Get(m_sendData, 0, len + CPacket.HEADER_LENGTH_BYTES);
m_currentSendBufferWritePosition = len + CPacket.HEADER_LENGTH_BYTES;
SendMsg(m_sendData);
}
}
}
}
/// <summary>
/// Processes receive events.
/// </summary>
/// <param name="e"></param>
public void ProcessReceive(SocketAsyncEventArgs e)
{
if (e.SocketError == SocketError.Success)
{
if (e.BytesTransferred > 0)
{
_readBuffer.Position = e.BytesTransferred;
_readBuffer.Flip();
if (ReuseBuffer)
{
EndReceive(_readBuffer);
}
else
{
IoBuffer buf = IoBuffer.Allocate(_readBuffer.Remaining);
buf.Put(_readBuffer);
buf.Flip();
EndReceive(buf);
}
return;
}
else
{
// closed
//Processor.Remove(this);
this.FilterChain.FireInputClosed();
}
}
else
{
EndReceive(new SocketException((Int32)e.SocketError));
}
}
/// <summary>
/// Processes receive events.
/// </summary>
/// <param name="e"></param>
public void ProcessReceive(SocketAsyncEventArgs e)
{
if (e.SocketError == SocketError.Success)
{
if (e.BytesTransferred > 0)
{
_readBuffer.Position = e.BytesTransferred;
_readBuffer.Flip();
if (ReuseBuffer)
{
EndReceive(_readBuffer);
}
else
{
IoBuffer buf = IoBuffer.Allocate(_readBuffer.Remaining);
buf.Put(_readBuffer);
buf.Flip();
EndReceive(buf);
}
return;
}
}
else if (e.SocketError != SocketError.OperationAborted &&
e.SocketError != SocketError.Interrupted)
{
EndReceive(new SocketException((Int32)e.SocketError));
}
}
/// <inheritdoc/>
public void MergeAll()
{
if (!_buffersOnly)
{
throw new InvalidOperationException("The encoded messages contains a non-buffer.");
}
if (_queue.Count < 2)
{
// no need to merge!
return;
}
Int32 sum = 0;
foreach (var item in _queue)
{
sum += ((IoBuffer)item).Remaining;
}
IoBuffer newBuf = IoBuffer.Allocate(sum);
for (; ;)
{
Object obj = _queue.Dequeue();
if (obj == null)
{
break;
}
newBuf.Put((IoBuffer)obj);
}
newBuf.Flip();
_queue.Enqueue(newBuf);
}
public override void Serialize(IoBuffer output, ISerializationContext context)
{
output.PutEnum(Type);
if (Type == MailRequestType.SEND)
{
byte[] dat;
if (Item == null)
{
dat = new byte[0];
}
else
{
using (var str = new MemoryStream())
{
Item.Save(str);
dat = str.ToArray();
}
}
output.PutInt32(dat.Length);
foreach (var b in dat)
{
output.Put(b);
}
}
else
{
output.PutInt64(TimestampID);
}
}
public void GetMsg(object o)
{
while (m_isSocketReady)
{
int recieveLen = 0;
try
{
if (m_mySocket.Available > 0)
{
recieveLen = m_mySocket.Client.Receive(m_getData, 0, (int)m_mySocket.ReceiveBufferSize, SocketFlags.None);
}
else
{
System.Threading.Thread.Sleep(1);
break;
}
}
catch (Exception e)
{
DEBUG.Error(e.Message);
break;
}
m_readBuffer.Put(m_getData, 0, recieveLen);
Array.Clear(m_getData, 0, m_getData.Length);
m_readBuffer.Flip();
int len = GetPacketLength(m_readBuffer);
if (len < 0)
{
break;
}
MessageBody msg = new MessageBody();
msg.size = (uint)CPacket.PopPacketLength(m_readBuffer);
msg.type = (ushort)CPacket.PopPacketType(m_readBuffer);
byte[] data = new byte[len - CPacket.HEADER_TYPE_BYTES];
m_readBuffer.Get(data, 0, len - CPacket.HEADER_TYPE_BYTES);
msg.data = data;
m_recievedMsgs.Add(msg);
bool isFinish = false;
if (m_readBuffer.HasRemaining)
{
m_readBuffer.Compact();
}
else
{
m_readBuffer.Clear();
isFinish = true;
}
if (isFinish)
{
break;
}
}
}
public override void Serialize(IoBuffer output, ISerializationContext context)
{
output.PutInt16(MaxLots);
output.PutInt16(CurrentLots);
output.Put(CpuPercentAvg);
output.PutInt64(RamUsed);
output.PutInt64(RamAvaliable);
}
public override void WriteByte(Byte value)
{
IoBuffer buf = IoBuffer.Allocate(1);
buf.Put(value);
buf.Flip();
_sslHandler.WriteBuffer(buf);
}
private void ReceiveCallback(IAsyncResult ar)
{
System.Net.Sockets.Socket socket = (System.Net.Sockets.Socket)ar.AsyncState;
Int32 read = 0;
try
{
read = socket.EndReceive(ar);
}
catch (ObjectDisposedException)
{
// do nothing
return;
}
catch (SocketException ex)
{
if (ex.SocketErrorCode != SocketError.OperationAborted &&
ex.SocketErrorCode != SocketError.Interrupted &&
ex.SocketErrorCode != SocketError.ConnectionReset)
{
EndReceive(ex);
}
else
{
// closed
Processor.Remove(this);
}
return;
}
catch (Exception ex)
{
EndReceive(ex);
return;
}
if (read > 0)
{
if (ReuseBuffer)
{
EndReceive(IoBuffer.Wrap(_readBuffer, 0, read));
}
else
{
IoBuffer buf = IoBuffer.Allocate(read);
buf.Put(_readBuffer, 0, read);
buf.Flip();
EndReceive(buf);
}
}
else
{
// closed
//Processor.Remove(this);
this.FilterChain.FireInputClosed();
}
}
public void Encode(IoSession session, PacketOutStream message, IProtocolEncoderOutput output)
{
int size = message.GetSize();
IoBuffer buf = IoBuffer.Allocate(size + 4);
buf.PutInt32(size);
buf.Put(message.getPackets2());
buf.Flip();
output.Write(buf);
}
public void Serialize(IoBuffer output, object value, ISerializationContext serializer)
{
var list = (IList <sbyte>)value;
output.PutUInt32((uint)list.Count);
for (int i = 0; i < list.Count; i++)
{
output.Put((byte)list[i]);
}
}
private void StoreRemainingInSession(IoBuffer buf, IoSession session)
{
IoBuffer remainingBuf = IoBuffer.Allocate(buf.Capacity);
remainingBuf.AutoExpand = true;
remainingBuf.Order = buf.Order;
remainingBuf.Put(buf);
session.SetAttribute(BUFFER, remainingBuf);
}
public void Serialize(IoBuffer output, object value, ISerializationContext serializer)
{
var dict = (ImmutableDictionary <uint, bool>)value;
output.PutUInt32((uint)dict.Count);
foreach (var elem in dict)
{
output.PutUInt32(elem.Key);
output.Put((byte)(elem.Value ? 1 : 0));
}
}
public void Serialize(IoBuffer output, ISerializationContext context)
{
output.PutUInt32(outfit_id);
output.PutUInt64(asset_id);
output.PutInt32(sale_price);
output.PutInt32(purchase_price);
output.PutEnum(owner_type);
output.PutUInt32(owner_id);
output.Put(outfit_type);
output.PutEnum(outfit_source);
}
public void Serialize(IoBuffer output, object value, ISerializationContext serializer)
{
var dat = (cTSOGenericData)value;
output.PutUInt32(0x0A2C6585);
output.PutUInt32((uint)dat.Data.Length);
for (int i = 0; i < dat.Data.Length; i++)
{
output.Put(dat.Data[i]);
}
}
public void Serialize(IoBuffer output, ISerializationContext context)
{
output.PutString(this.User, 112, Encoding.ASCII);
output.PutString(this.AriesVersion, 80, Encoding.ASCII);
output.PutString(this.Email, 40, Encoding.ASCII);
output.PutString(this.Authserv, 84, Encoding.ASCII);
output.PutUInt16(this.Product);
output.Put(this.Unknown);
output.PutString(this.ServiceIdent, 3, Encoding.ASCII);
output.PutUInt16(this.Unknown2);
output.PutString(this.Password, 32, Encoding.ASCII);
}
/// <inheritdoc/>
public Int32 Read(IoBuffer buffer)
{
using (FileStream fs = _file.OpenRead())
{
fs.Position = _position;
Byte[] bytes = new Byte[buffer.Remaining];
Int32 read = fs.Read(bytes, 0, bytes.Length);
buffer.Put(bytes, 0, read);
Update(read);
return(read);
}
}
