public void Send(NetPacketHeader header, NetBuffer buffer)
{
header.size = (uint)buffer.size;
var headerSize = Marshal.SizeOf(header);
var headerByteArray = new byte[Marshal.SizeOf(header)];
header.Write(headerByteArray, 0, headerSize - 1);
lock (combineSendLock)
{
Send(headerByteArray, 0, headerByteArray.Length);
if (buffer.size != 0)
{
Send(buffer);
}
}
}
public static int ReadList(List <NetPacketHeader> sValArray, byte[] byteArray, int begin, int end)
{
if (end - begin + 1 < 4)
{
throw new NoSufficentSpaceException(4, begin, end);
}
int size = System.BitConverter.ToInt32(byteArray, begin);
int length = size / 10;
sValArray.Clear();
sValArray.Capacity = length;
begin += 4;
if (end - begin + 1 < size)
{
throw new NoSufficentSpaceException(10 * length, begin, end);
}
int offset = begin;
for (int i = 0; i < length; ++i)
{
var value = new NetPacketHeader();
value.b00 = byteArray[offset + 0];
value.b01 = byteArray[offset + 1];
value.b02 = byteArray[offset + 2];
value.b03 = byteArray[offset + 3];
value.b04 = byteArray[offset + 4];
value.b05 = byteArray[offset + 5];
value.b06 = byteArray[offset + 6];
value.b07 = byteArray[offset + 7];
value.b08 = byteArray[offset + 8];
value.b09 = byteArray[offset + 9];
sValArray.Add(value);
offset += 10;
}
return(offset);
}
void BeginSend(NetBuffer buffer, bool forceSend)
{
lock (sendLock)
{
if (sending && !forceSend)
{
#if ENABLE_NET_DIAGNOSTICS
buffer.index = _bufferIndex;
_bufferIndex++;
#endif
sendBufferQueue.Enqueue(buffer);
return;
}
else
{
sending = true;
}
}
if (sendEventArgs == null)
{
sendEventArgs = new SocketAsyncEventArgs();
sendEventArgs.Completed += OnIOComplete;
}
sendEventArgs.SetBuffer(buffer.byteArray, buffer.offset, buffer.size);
sendingBuffer = buffer;
while (true)
{
#if ENABLE_NET_DIAGNOSTICS
Output.LogFormat("SEND <{0} {1}> {2} T = {3}",
sendingBuffer.offset, sendingBuffer.size,
sendingBuffer.index,
System.Threading.Thread.CurrentThread.ManagedThreadId);
if (sendingBuffer.size == 10)
{
NetPacketHeader dummyHeader = new NetPacketHeader();
dummyHeader.Read(sendingBuffer.byteArray, sendingBuffer.offset, sendingBuffer.size);
Output.LogFormat("HEADER CMD = {0}, SIZE = {1}", dummyHeader.cmd, dummyHeader.size);
}
#endif
if (!socket.Connected || socket.SendAsync(sendEventArgs))
{
break;
}
if (!OnSent(sendEventArgs, false, out sendingBuffer))
{
break;
}
if (sendingBuffer.size == 0)
{
break;
}
sendEventArgs.SetBuffer(sendingBuffer.byteArray, sendingBuffer.offset, sendingBuffer.size);
}
}
bool OnReceived(SocketAsyncEventArgs e, bool callReceiveWhenFinished)
{
if (e.BytesTransferred > 0 && e.SocketError == SocketError.Success)
{
var headerSize = Marshal.SizeOf <NetPacketHeader>();
var remainBuffer = new NetBuffer
{
byteArray = e.Buffer,
offset = 0,
size = e.BytesTransferred
};
while (remainBuffer.size > 0)
{
if (receivingHeaderOffset < headerSize)
{
var oldRemainBuffer = remainBuffer;
var originHeaderOffset = receivingHeaderOffset;
var remainBufferOffset = receivingHeader.ReadPartial(
remainBuffer.byteArray, receivingHeaderOffset,
remainBuffer.offset, remainBuffer.offset + remainBuffer.size - 1);
var readBytes = remainBufferOffset - remainBuffer.offset;
receivingHeaderOffset += readBytes;
remainBuffer.Consume(readBytes);
#if ENABLE_NET_DIAGNOSTICS
Output.LogErrorFormat(
"READ HEADER (CMD {0} FLAGS {1} SLCODE {2} SIZE {3}) (OFFSET {4} => {5}) (REMAIN {6} => {7}) T = {8}",
receivingHeader.cmd, receivingHeader.flags, receivingHeader.slCode,
receivingHeader.size,
originHeaderOffset, receivingHeaderOffset,
oldRemainBuffer.offset, oldRemainBuffer.offset + oldRemainBuffer.size - 1,
System.Threading.Thread.CurrentThread.ManagedThreadId);
#endif
if (receivingHeaderOffset >= headerSize)
{
if (receivingHeaderOffset > headerSize ||
receivingHeader.size > maxReceiveBodySize)
{
Output.LogErrorFormat(
"CORRUPT HEADER (CMD {0} FLAGS {1} SLCODE {2} SIZE {3}) (OFFSET {4} => {5}) (REMAIN {6} => {7}) T = {8}",
receivingHeader.cmd, receivingHeader.flags, receivingHeader.slCode,
receivingHeader.size,
originHeaderOffset, receivingHeaderOffset,
oldRemainBuffer.offset, oldRemainBuffer.offset + oldRemainBuffer.size - 1,
System.Threading.Thread.CurrentThread.ManagedThreadId);
Output.LogErrorFormat(
"{0:X} {1:X} {2:X} {3:X} {4:X} {5:X} {6:X} {7:X} {8:X} {9:X}",
oldRemainBuffer.byteArray[oldRemainBuffer.offset],
oldRemainBuffer.byteArray[oldRemainBuffer.offset + 1],
oldRemainBuffer.byteArray[oldRemainBuffer.offset + 2],
oldRemainBuffer.byteArray[oldRemainBuffer.offset + 3],
oldRemainBuffer.byteArray[oldRemainBuffer.offset + 4],
oldRemainBuffer.byteArray[oldRemainBuffer.offset + 5],
oldRemainBuffer.byteArray[oldRemainBuffer.offset + 6],
oldRemainBuffer.byteArray[oldRemainBuffer.offset + 7],
oldRemainBuffer.byteArray[oldRemainBuffer.offset + 8],
oldRemainBuffer.byteArray[oldRemainBuffer.offset + 9]
);
Close();
return(false);
}
receivingBuffer = new NetBuffer
{
byteArray = new byte[receivingHeader.size],
offset = 0,
size = (int)receivingHeader.size
};
}
}
else
{
var byteNumToCopy = Math.Min(remainBuffer.size, receivingBuffer.size);
Buffer.BlockCopy(
remainBuffer.byteArray, (int)remainBuffer.offset,
receivingBuffer.byteArray, (int)receivingBuffer.offset,
byteNumToCopy);
remainBuffer.Consume(byteNumToCopy);
receivingBuffer.Consume(byteNumToCopy);
}
if (receivingBuffer.byteArray != null && receivingBuffer.size == 0)
{
var packetAndBuffer = new NetPacketAndBuffer(
receivingHeader, receivingBuffer.Begin);
receivingHeader = NetPacketHeader.Empty;
receivingBuffer = NetBuffer.Empty;
receivingHeaderOffset = 0;
if (packetAndBuffer.Item2.byteArray != null)
{
try
{
if (manuallyFetchReceivedBuffer)
{
receiveBufferQueue.Enqueue(packetAndBuffer);
}
else
{
DoReceiveEvent(packetAndBuffer);
}
}
catch (Exception exception)
{
Output.LogError(exception);
}
}
}
}
if (callReceiveWhenFinished)
{
BeginReceive(0);
}
}
else if (e.SocketError != SocketError.Success)
{
Output.LogFormat("RECV ERROR: {0}", e.SocketError);
Close();
return(false);
}
return(true);
}
