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); } }