private bool Send(byte[] buffer, int offset, int count, int protocolId, int channelId)
{
bool result;
if (!IsConnected())
{
LoggerManager.Instance.Info("Send protocolId {0}-{0:X} but connected false", protocolId);
result = false;
}
else
{
this.channelId = channelId;
NetworkBuffer networkBuffer = new NetworkBuffer(count + 4, true);
networkBuffer.Write(protocolId);
networkBuffer.Write(buffer, offset, count);
if (handlerPipeline.OutHeader != null)
{
handlerPipeline.OutHeader.Send(this, networkBuffer.GetBuffer(), networkBuffer.ReadOffset, networkBuffer.ReadableBytes);
result = true;
}
else
{
LoggerManager.Instance.Info("IConnection.Send data protocolId {0}-{0:X} then call_Send", protocolId);
result = Send(networkBuffer.GetBuffer(), networkBuffer.ReadOffset, networkBuffer.ReadableBytes);
}
}
return(result);
}
public override void Send(IConnection connection, byte[] buffer, int offset, int size)
{
NetworkBuffer networkBuffer = new NetworkBuffer(size + 1, true);
networkBuffer.Write(Message.UnCompressed);
networkBuffer.Write(buffer, offset, size);
SendBuffDown(connection, networkBuffer.GetBuffer(), networkBuffer.ReadOffset, networkBuffer.ReadableBytes);
}
public NetworkBuffer EncodeWithSnappyProtocolIdCallBackId()
{
NetworkBuffer networkBuffer = new NetworkBuffer(NetworkParameters.MaxSendBufferSize, true);
networkBuffer.Write(UnCompressed);
networkBuffer.Write(ProtocolId);
networkBuffer.Write(callBackId);
EncodeBody(networkBuffer);
return(networkBuffer);
}
private void OnReadResult(IAsyncResult ar)
{
NetworkStream stream = mTcpClient.GetStream();
int numberOfReadBytes;
try
{
numberOfReadBytes = stream.EndRead(ar);
}
catch
{
numberOfReadBytes = 0;
}
if (numberOfReadBytes == 0)
{
// connection has been closed
Close();
return;
}
// received byte and trigger event notification
byte[] buffer = (byte[])ar.AsyncState;
mReadBuffer.Write(buffer, 0, numberOfReadBytes);
try
{
OnHandleRead();
}
catch (Exception e)
{
Logger.ErrorLine(e.Message);
}
stream.BeginRead(buffer, 0, buffer.Length, OnReadResult, buffer);
}
protected int msgCount; //数据部分实际长度
public void OnReceived(Connection connection, byte[] buffer, int offset, int count)
{
if (networkBuffer == null)
{
networkBuffer = new NetworkBuffer(NHNet._MAX_COMPRESS_MESSAGE_SIZE, true);
}
networkBuffer.Write(buffer, offset, count);
try
{
CallDecode(connection);
}
catch (Exception e)
{
LogU.Debug(e.Message);
LogU.Debug(e.StackTrace);
//通知connection，连接异常
if (null != connection.OnReceived)
{
connection.OnReceived(connection, null, 0, -1);
}
}
}
public override void Send(IConnection connection, byte[] buffer, int offset, int size)
{
int num = size + lengthAdjustment;
if (lengthIncludesLengthFieldLength)
{
num += lengthFieldLength;
}
if (num < 0)
{
throw new ArgumentException("Adjusted frame length (" + num + ") is less than zero");
}
NetworkBuffer networkBuffer = new NetworkBuffer(size + lengthFieldLength, true);
switch (lengthFieldLength)
{
case 1:
if (num >= 256)
{
throw new ArgumentException("length does not fit into a byte: " + num);
}
networkBuffer.Write((byte)num);
goto IL_EC;
case 2:
if (num >= 65536)
{
throw new ArgumentException("length does not fit into a short integer: " + num);
}
networkBuffer.Write((short)num);
goto IL_EC;
case 4:
networkBuffer.Write(num);
goto IL_EC;
}
throw new ArgumentException("should not reach here");
IL_EC:
networkBuffer.Write(buffer, offset, size);
SendBuffDown(connection, networkBuffer.GetBuffer(), networkBuffer.ReadOffset, networkBuffer.ReadableBytes);
}
private void DataReceived(Task <int> task)
{
try
{
// SocketError err;
if (state == SocketState.Closed || state == SocketState.Terminated)
{
return;
}
if (task.Result <= 0)
{
Close();
return;
}
//if (receiveNetworkBuffer.Protected)
// Console.WriteLine();
//lock (receiveNetworkBuffer.SyncLock)
receiveNetworkBuffer.Write(receiveBuffer, 0, (uint)task.Result);
//Console.WriteLine("TC IN: " + (uint)task.Result + " " + DC.ToHex(receiveBuffer, 0, (uint)task.Result));
OnReceive?.Invoke(receiveNetworkBuffer);
if (state == SocketState.Established)
{
sock.ReceiveAsync(receiveBufferSegment, SocketFlags.None).ContinueWith(DataReceived);
}
}
catch (Exception ex)
{
if (state != SocketState.Closed && !sock.Connected)
{
state = SocketState.Terminated;
Close();
}
Global.Log("TCPSocket", LogType.Error, ex.ToString());
}
}
public void Send(byte[] message)
{
lock (sendLock)
{
if (held)
{
sendNetworkBuffer.Write(message);
}
else
{
totalSent += message.Length;
//Console.WriteLine("TX " + message.Length +"/"+totalSent);// + " " + DC.ToHex(message, 0, (uint)size));
pkt_send.Message = message;
if (pkt_send.Compose())
{
sock?.Send(pkt_send.Data);
}
}
}
}
public override void OnReceived(IConnection connection, byte[] buffer, int offset, int count)
{
if (msgBuffer == null)
{
msgBuffer = new NetworkBuffer(NetworkParameters.MaxCompressMessageSize, true);
}
msgBuffer.Write(buffer, offset, count);
try
{
while (msgBuffer.Readable)
{
int readOffset = msgBuffer.ReadOffset;
int num = 0;
if (!Decode(msgBuffer, ref num))
{
if (readOffset == msgBuffer.ReadOffset)
{
break;
}
}
else
{
if (num == 0)
{
throw new InvalidOperationException("decode() method must read at least one byte if it returned a frame ");
}
try
{
FireBuffReceived(connection, msgBuffer.GetBuffer(), msgBuffer.ReadOffset, num);
}
finally
{
msgBuffer.ReadOffset = msgBuffer.ReadOffset + num;
msgBuffer.DiscardReadBytes();
}
}
}
}
catch (Exception ex)
{
LoggerManager.Instance.Info("OnReceived connection {0} catch Exception {1}", connection.ToString(), ex.ToString());
}
}
protected byte[] OnHandleWrite(IMessage message)
{
mHeartbeatWatch.Start();
if (message.SessionId != 0)
{
mMessages.Add(message.SessionId, message);
}
message.Version = mMessageVersion;
message.OnSend(this);
ArraySegment <byte>?data;
if (message.IsRequest)
{
data = message.SerializeRequest();
}
else
{
data = message.SerializeResponse();
}
int totalSize = (data?.Count ?? 0) + 4 * 6;
mWriteBuffer.Write(totalSize);
mWriteBuffer.Write(message.FromService);
mWriteBuffer.Write(message.ToService);
mWriteBuffer.Write(message.Version);
mWriteBuffer.Write(message.Id);
mWriteBuffer.Write(message.SessionId);
mWriteBuffer.Write(message.ConnectionId);
if (data != null)
{
mWriteBuffer.Write(data.Value.Array, data.Value.Offset, data.Value.Count);
}
return(mWriteBuffer.ReadAll());
}
public void TestReadWriteMissaligned()
{
var outNetworkBuffer = new NetworkBuffer();
var outNetworkWriter = new NetworkWriter(outNetworkBuffer);
outNetworkWriter.WriteBit(true);
var writeBuffer = new byte[16]
{
0,
5,
2,
54,
192,
60,
214,
65,
95,
2,
43,
62,
252,
190,
45,
2
};
outNetworkBuffer.Write(writeBuffer);
var inNetworkBuffer = new NetworkBuffer(outNetworkBuffer.GetBuffer());
Assert.That(inNetworkBuffer.ReadBit(), Is.True);
var readBuffer = new byte[16];
inNetworkBuffer.Read(readBuffer, 0, 16);
Assert.That(readBuffer, Is.EquivalentTo(writeBuffer));
}
private void DataReceived(Task <int> task)
{
try
{
// SocketError err;
if (state == SocketState.Closed || state == SocketState.Terminated)
{
return;
}
if (task.Result <= 0)
{
Close();
return;
}
receiveNetworkBuffer.Write(receiveBuffer, 0, (uint)task.Result);
OnReceive?.Invoke(receiveNetworkBuffer);
if (state == SocketState.Established)
{
ssl.ReadAsync(receiveBuffer, 0, receiveBuffer.Length).ContinueWith(DataReceived);
}
}
catch (Exception ex)
{
if (state != SocketState.Closed && !sock.Connected)
{
state = SocketState.Terminated;
Close();
}
Global.Log("SSLSocket", LogType.Error, ex.ToString());
}
}
private void ReceiveCallback(IAsyncResult results)
{
try
{
if (state != SocketState.Established)
{
return;
}
var bytesReceived = ssl.EndRead(results);
if (bytesReceived <= 0)
{
Close();
return;
}
receiveNetworkBuffer.Write(receiveBuffer, 0, (uint)bytesReceived);
//OnReceive?.Invoke(receiveNetworkBuffer);
Receiver?.NetworkReceive(this, receiveNetworkBuffer);
ssl.BeginRead(receiveBuffer, 0, receiveBuffer.Length, ReceiveCallback, this);
}
catch //(Exception ex)
{
if (state != SocketState.Closed && !sock.Connected)
{
//state = SocketState.Terminated;
Close();
}
//Global.Log("SSLSocket", LogType.Error, ex.ToString());
}
}
private void Sock_OnReceive(NetworkBuffer buffer)
{
if (sock.State == SocketState.Closed || sock.State == SocketState.Terminated)
{
return;
}
if (buffer.Protected)
{
return;
}
if (processing)
{
return;
}
var msg = buffer.Read();
if (msg == null)
{
return;
}
var wsPacketLength = pkt_receive.Parse(msg, 0, (uint)msg.Length);
//Console.WriteLine("WSP: " + wsPacketLength);
if (wsPacketLength < 0)
{
buffer.Protect(msg, 0, (uint)msg.Length + (uint)-wsPacketLength);
return;
}
uint offset = 0;
while (wsPacketLength > 0)
{
if (pkt_receive.Opcode == WebsocketPacket.WSOpcode.ConnectionClose)
{
Close();
return;
}
else if (pkt_receive.Opcode == WebsocketPacket.WSOpcode.Ping)
{
var pkt_pong = new WebsocketPacket();
pkt_pong.FIN = true;
pkt_pong.Mask = false;
pkt_pong.Opcode = WebsocketPacket.WSOpcode.Pong;
pkt_pong.Message = pkt_receive.Message;
offset += (uint)wsPacketLength;
Send(pkt_pong);
}
else if (pkt_receive.Opcode == WebsocketPacket.WSOpcode.Pong)
{
offset += (uint)wsPacketLength;
}
else if (pkt_receive.Opcode == WebsocketPacket.WSOpcode.BinaryFrame ||
pkt_receive.Opcode == WebsocketPacket.WSOpcode.TextFrame ||
pkt_receive.Opcode == WebsocketPacket.WSOpcode.ContinuationFrame)
{
totalReceived += pkt_receive.Message.Length;
//Console.WriteLine("RX " + pkt_receive.Message.Length + "/" + totalReceived);// + " " + DC.ToHex(message, 0, (uint)size));
receiveNetworkBuffer.Write(pkt_receive.Message);
offset += (uint)wsPacketLength;
//Console.WriteLine("WS IN: " + pkt_receive.Opcode.ToString() + " " + pkt_receive.Message.Length + " | " + offset + " " + string.Join(" ", pkt_receive.Message));// DC.ToHex(pkt_receive.Message));
}
else
{
Console.WriteLine("Unknown WS opcode:" + pkt_receive.Opcode);
}
if (offset == msg.Length)
{
// Console.WriteLine("WS IN: " + receiveNetworkBuffer.Available);
OnReceive?.Invoke(receiveNetworkBuffer);
return;
}
wsPacketLength = pkt_receive.Parse(msg, offset, (uint)msg.Length);
}
if (wsPacketLength < 0)//(offset < msg.Length) && (offset > 0))
{
//receiveNetworkBuffer.HoldFor(msg, offset, (uint)(msg.Length - offset), (uint)msg.Length + (uint)-wsPacketLength);
// save the incomplete packet to the heldBuffer queue
buffer.HoldFor(msg, offset, (uint)(msg.Length - offset), (uint)(msg.Length - offset) + (uint)-wsPacketLength);
}
//Console.WriteLine("WS IN: " + receiveNetworkBuffer.Available);
OnReceive?.Invoke(receiveNetworkBuffer);
processing = false;
if (buffer.Available > 0 && !buffer.Protected)
{
Sock_OnReceive(buffer);
}
}
