/// <summary> /// Session结束事件调用 /// </summary> /// <param name="_session">SocketSession 对象</param> internal virtual void OnSessionEnd(SocketSession _session) { if (this.OnSessionEndEvent != null && _session != null) { this.OnSessionEndEvent(_session); } }
public byte[] EnPackage(object _object, SocketSession _session = null) { string _json = ((JObject)_object).ToString(Newtonsoft.Json.Formatting.None); string _data = OpenSSLAes.Encode(_json, this.key) + "\n"; return(Encoding.UTF8.GetBytes(_data)); }
public byte[] EnPackage(object _object, SocketSession _session = null) { WstpPackage _package = (WstpPackage)_object; int _payloadByte = 0; if (_package.Binary.Length >= 65536) { _payloadByte = 8; } else if (_package.Binary.Length >= 126) { _payloadByte = 2; } byte[] _data = new byte[2 + _payloadByte + _package.Binary.Length]; _data[0] = 0; _data[1] = 0; _data[0] |= 0x80; switch (_package.Type) { case WstpPackageType.Ping: _data[0] |= 0x09; break; case WstpPackageType.Pong: _data[0] |= 0x0A; break; case WstpPackageType.Text: _data[0] |= 0x01; break; case WstpPackageType.Binary: _data[0] |= 0x02; break; case WstpPackageType.Close: _data[0] |= 0x08; break; } if (_payloadByte == 0) { _data[1] = (byte)_package.Binary.Length; Array.Copy(_package.Binary, 0, _data, 2, _package.Binary.Length); } else if (_payloadByte == 2) { _data[1] = 126; ushort _size = ushort.Parse(_package.Binary.Length.ToString()); short _sizeNet = System.Net.IPAddress.HostToNetworkOrder((short)_size); byte[] _length = BitConverter.GetBytes(_sizeNet); Array.Copy(_length, 0, _data, 2, _length.Length); Array.Copy(_package.Binary, 0, _data, 4, _package.Binary.Length); } else { _data[1] = 127; int _size = _package.Binary.Length; long _sizeNet = System.Net.IPAddress.HostToNetworkOrder((long)_size); byte[] _length = BitConverter.GetBytes(_sizeNet); Array.Copy(_length, 0, _data, 2, _length.Length); Array.Copy(_package.Binary, 0, _data, 10, _package.Binary.Length); } return(_data); }
/// <summary> /// 开始接受连入 /// </summary> private void BeginAccept() { while (!this._shutingdown) { SocketSession _socketSession = this.Sessions.Pop(); if (_socketSession == null) { Thread.Sleep(100); continue; } #region Session池可用 _socketSession.Handshaked = false; _socketSession.Status = SocketSessionStatus.Accepting; try { try { if (!this.socket.AcceptAsync(_socketSession.SocketAsyncEventArgs)) { this.EndAccept(_socketSession.SocketAsyncEventArgs); } } catch (InvalidOperationException) { int _index = _socketSession.Index; _socketSession.Dispose(); _socketSession = new SocketSession(this, _index); _socketSession.SocketAsyncEventArgs.Completed += new EventHandler <SocketAsyncEventArgs>(Async_Completed); this.Sessions[_index] = _socketSession; if (!this.socket.AcceptAsync(_socketSession.SocketAsyncEventArgs)) { this.EndAccept(_socketSession.SocketAsyncEventArgs); } } } catch (ObjectDisposedException _ex) { if (_ex.ObjectName != "Socket") { this.OnException(_ex); } } catch (Exception _ex) { this.OnException(_ex); } #endregion return; } }
/// <summary> /// Session开始事件调用 /// </summary> /// <param name="_session">SocketSession 对象</param> internal virtual void OnSessionStart(SocketSession _session) { if (this._shutingdown) { return; } if (this.OnSessionStartEvent != null && _session != null) { this.OnSessionStartEvent(_session); } }
public bool ReceiveFirstPackage(JObject _json, SocketSession _session) { if (_session["TxKey"] + "" != "" && _session["Checksum"] + "" == "DONE") { return(false); } if (_session["RxKey"] + "" == "") { DateTime _time = DateTimePlus.JSTime2DateTime(long.Parse(_json["time"].Value <string>())); if (Math.Abs((_time - DateTime.UtcNow).TotalSeconds) > 300) { _session.Disconnect(); return(true); } _session["TxKey"] = _json["key"].Value <string>(); Random _random = new Random(RandomPlus.RandomSeed); string _rxKey = _random.Next(10000000, 100000000).ToString(); _session["RxKey"] = _rxKey; string _checksum = _random.Next(10000000, 100000000).ToString(); _session["Checksum"] = _checksum; JObject _result = new JObject(); _result["check"] = this.rsa.Sign(_json["num"].Value <string>()); _result["num"] = _checksum; _result["key"] = _rxKey; _session.SendPackage(_result); } else if (_session["Checksum"] + "" != "DONE") { if (!this.rsa.Verify(_session["Checksum"] + "", _json["check"].Value <string>())) { this.socketTxKey = ""; return(true); } _session["Checksum"] = "DONE"; _session.Handshaked = true; } return(true); }
/// <summary> /// 接受到连入处理 /// </summary> /// <param name="_socketAsyncEventArgs">异步Socket对象</param> private void EndAccept(SocketAsyncEventArgs _socketAsyncEventArgs) { SocketSession _socketSession = (SocketSession)_socketAsyncEventArgs.UserToken; if (_socketAsyncEventArgs.SocketError != SocketError.Success || !this.OnSocketAccept(_socketAsyncEventArgs.AcceptSocket)) { _socketSession.Clear(); this.BeginAccept(); return; } if (!this.bufferManager.SetBuffer(_socketAsyncEventArgs)) { throw new OverflowException("Out of buffer."); } try { if (this.keepAliveIO) { _socketAsyncEventArgs.AcceptSocket.IOControl(IOControlCode.KeepAliveValues, this.keepAliveByteArray, null); } DateTime _now = DateTime.UtcNow; _socketSession.LastOperationTime = _now; _socketSession.Id = _now.ToString("yyyyMMddHHmmss") + _socketSession.Index.ToString("00000000"); _socketSession.Status = SocketSessionStatus.Connected; this.OnSessionStart(_socketSession); this.BeginReceive(_socketAsyncEventArgs); } catch (Exception) { this.bufferManager.FreeBuffer(_socketAsyncEventArgs); _socketSession.Clear(); } finally { this.BeginAccept(); } }
private void Timeout() { while (this.timeroutThreadRunning) { for (int i = 0; i < this.Sessions.Length; i++) { SocketSession _socketSession = this.Sessions[i]; if (_socketSession.Status != SocketSessionStatus.Connected) { continue; } uint _keep = _socketSession.Protocol == null ? this.keepAlive : _socketSession.Protocol.KeepAlive; if (_keep > 0 && _socketSession.LastOperationTime.AddMilliseconds(_keep) < DateTime.UtcNow) { _socketSession.Handshaked = false; _socketSession.Disconnect(); } } Thread.Sleep(1000); } }
public byte[] EnPackage(object _object, SocketSession _session = null) { string _key = ""; if (_session == null) { _key = this.socketTxKey == "" ? this.socketKey : this.socketTxKey; } else { _key = _session["TxKey"] + ""; } if (_key == "") { throw new Exception("EnPackage failed: TxKey is empty."); } string _content = ((JObject)_object).ToString(Newtonsoft.Json.Formatting.None); byte[] _contentArray = DES.Encode2ByteArray(System.Text.Encoding.UTF8.GetBytes(_content), _key, System.Security.Cryptography.CipherMode.CBC); uint _length = uint.Parse(_contentArray.Length.ToString()) + 4 + 16; byte[] _lengthArray = BitConverter.GetBytes(_length); if (BitConverter.IsLittleEndian) { Array.Reverse(_lengthArray); } byte[] _byteArray = new byte[_length - 16]; Array.Copy(_lengthArray, _byteArray, 4); Array.Copy(_contentArray, 0, _byteArray, 4, _contentArray.Length); byte[] _md5Array = MD5.Encode2ByteArray(_byteArray); Array.Resize(ref _byteArray, _byteArray.Length + 16); Array.Copy(_md5Array, 0, _byteArray, _byteArray.Length - 16, 16); return(_byteArray); }
/// <summary> /// 开始监听端口 /// </summary> /// <param name="_endPoint">监听端口</param> /// <returns>是否成功监听端口</returns> private bool Listen(EndPoint _endPoint) { try { this.type = SocketEngineType.Server; this.socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); this.socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, 1); this.socket.LingerState.LingerTime = 0; this.socket.Bind(_endPoint); this.socket.Listen(this.limitedPending); this.bufferManager = new SocketEngineBuffer(this.LimitedSession, 4096); this.bufferManager.Init(); this.Sessions = new SocketSessionCollection(this.limitedSession); for (int i = 0; i < this.LimitedSession; i++) { SocketSession _socketSession = new SocketSession(this, i); _socketSession.SocketAsyncEventArgs.Completed += new EventHandler <SocketAsyncEventArgs>(Async_Completed); this.Sessions[i] = _socketSession; } this.timeroutThreadRunning = true; this.timeoutThread = new Thread(new ThreadStart(this.Timeout)); this.timeoutThread.Start(); this.BeginAccept(); return(true); } catch (Exception _ex) { this.OnException(_ex); return(false); } }
public bool Check(byte[] _byteArray, bool _completely = false, SocketSession _session = null) { object _data = this.DePackage(_byteArray, out uint _packageSize, false, _session); return(_data != null); }
public object DePackage(byte[] _byteArray, out uint _packageSize, bool _completely = false, SocketSession _session = null) { if (_session == null) { _packageSize = uint.Parse(_byteArray.Length.ToString()); return(null); } string _data = ""; if (_session["__I__N__I__T__"] == null) { #region 首次握手 _data = Encoding.UTF8.GetString(_byteArray); int _index = _data.IndexOf("\r\n\r\n"); if (_index == -1) { _packageSize = 0; return(null); } if (!_completely && _index > -1) { _packageSize = 0; return(new WstpPackage(WstpPackageType.Init)); } _packageSize = uint.Parse((_index + 4).ToString()); string[] _lines = _data.Split("\r\n"); Dictionary <string, string> _header = new Dictionary <string, string>(); foreach (string _line in _lines) { string _key = ""; string _value = ""; if (_line.StartsWith("GET")) { _key = "Path"; _value = _line.Substring(4, _line.IndexOf(" ", 4) - 4); } else { int _splitIndex = _line.IndexOf(":"); if (_splitIndex == -1) { continue; } _key = _line.Substring(0, _splitIndex).Trim(); _value = _line.Substring(_splitIndex + 1).Trim(); } if (_header.ContainsKey(_key)) { _header[_key] = _header[_key] + "\n" + _value; } else { _header.Add(_key, _value); } } if (!_header.ContainsKey("Upgrade") || _header["Upgrade"] != "websocket") { _packageSize = 0; _session.Disconnect(); return(null); } if (_header.ContainsKey("Sec-WebSocket-Key")) { string _wsKey = _header["Sec-WebSocket-Key"]; if (_wsKey == "") { _packageSize = 0; _session.Dispose(); return(null); } string _wsSecret = SHA.EncodeSHA1ToBase64(_wsKey + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"); string _returnData = $"HTTP/1.1 101 Switching Protocols\r\n"; _returnData += $"Connection:Upgrade\r\n"; _returnData += $"Server:{this.name}\r\n"; _returnData += $"Upgrade:WebSocket\r\n"; _returnData += $"Date:{DateTime.UtcNow.ToString("r")}\r\n"; _returnData += $"Sec-WebSocket-Accept:{_wsSecret}\r\n\r\n"; _session.SendBytes(Encoding.UTF8.GetBytes(_returnData)); foreach (KeyValuePair <string, string> _item in _header) { _session[$"{_item.Key}"] = _item.Value; } _session["Sec-WebSocket-Secret"] = _wsSecret; _session["__I__N__I__T__"] = true; return(new WstpPackage(WstpPackageType.Init)); } else if (_header.ContainsKey("Sec-WebSocket-Key1")) { string _origin = _header["Origin"]; if (_origin.Length == 0) { _origin = "null"; } string _returnData = $"HTTP/1.1 101 Web Socket Protocol Handshake\r\n"; _returnData += $"Upgrade:WebSocket\r\n"; _returnData += $"Connection:Upgrade\r\n"; _returnData += $"Server:{this.name}\r\n"; _returnData += $"Date:{DateTime.UtcNow.ToString("r")}\r\n"; _returnData += $"Sec-WebSocket-Origin:{_origin}\r\n\r\n"; _returnData += $"Sec-WebSocket-Location:ws://{_header["Host"]}{_header["Path"]}\r\n\r\n"; uint _key1 = GetWebSocketKeyValue(_header["Sec-WebSocket-Key1"]); uint _key2 = GetWebSocketKeyValue(_header["Sec-WebSocket-Key2"]); string _keyExt = _lines[_lines.Length - 1]; if (_keyExt.Length < 8) { _packageSize = 0; _session.Disconnect(); return(null); } byte[] _buffer = new byte[16]; byte[] _key1Bytes = BitConverter.GetBytes(_key1); byte[] _key2Bytes = BitConverter.GetBytes(_key2); byte[] _keyExtBytes = Encoding.UTF8.GetBytes(_keyExt); Array.Copy(_key1Bytes, 0, _buffer, 0, _key1Bytes.Length); Array.Copy(_key2Bytes, 0, _buffer, _key2Bytes.Length, _key2Bytes.Length); Array.Copy(_keyExtBytes, 0, _buffer, _key1Bytes.Length + _key2Bytes.Length, _keyExtBytes.Length); _returnData += Encrypt.MD5.Encode(_buffer); _session.SendBytes(Encoding.UTF8.GetBytes(_returnData)); foreach (KeyValuePair <string, string> _item in _header) { _session[$"{_item.Key}"] = _item.Value; } _session["__I__N__I__T__"] = true; return(new WstpPackage(WstpPackageType.Init)); } #endregion } int _start = 0; _packageSize = 0; WstpPackage _package = null; if (_byteArray.Length == 0) { return(_package); } while (true) { int _fin = (_byteArray[_start] & 0x80) == 0x80 ? 1 : 0; if (_fin == 0) { break; } int _op = _byteArray[_start] & 0x0F; int _len = _byteArray[_start + 1] & 0x7F; int _lenByByte = 1; int _maskByByte = 4; if (_len == 126) { _lenByByte = 3; } else if (_len == 127) { _lenByByte = 9; } if ((_byteArray.Length - _start) < (1 + _lenByByte + _maskByByte)) { break; } if (_len == 126) { byte[] _buffer = new byte[2]; Array.Copy(_byteArray, _start + 2, _buffer, 0, _buffer.Length); _len = System.Net.IPAddress.NetworkToHostOrder(BitConverter.ToInt16(_buffer, 0)); } else if (_len == 127) { byte[] _buffer = new byte[8]; Array.Copy(_byteArray, _start + 2, _buffer, 0, _buffer.Length); _len = (int)System.Net.IPAddress.NetworkToHostOrder((long)BitConverter.ToInt64(_buffer, 0)); } if ((_byteArray.Length - _start) < (1 + _lenByByte + _maskByByte + _len)) { break; } if (_op == 8) { _session.SendPackage(new WstpPackage(WstpPackageType.Close)); _session.Disconnect(); _package = new WstpPackage(WstpPackageType.Close); } else if (_op == 9) { _session.SendPackage(new WstpPackage(WstpPackageType.Pong)); _package = new WstpPackage(WstpPackageType.Ping); } byte[] _mask = new byte[_maskByByte]; Array.Copy(_byteArray, _start + 1 + _lenByByte, _mask, 0, _maskByByte); byte[] _payload = new byte[_len]; Array.Copy(_byteArray, _start + 1 + _lenByByte + _maskByByte, _payload, 0, _len); if (_package == null && _op == 1) { _package = new WstpPackage(WstpPackageType.Text); } if (_package == null && _op == 2) { _package = new WstpPackage(WstpPackageType.Binary); } if (_package == null) { return(null); } int _binaryLen = _package.Binary.Length; Array.Resize(ref _package.Binary, _package.Binary.Length + _payload.Length); for (int i = 0; i < _payload.Length; i++) { _package.Binary[_binaryLen + i] = (byte)(_payload[i] ^ _mask[i % 4]); } _start = _start + 1 + _lenByByte + _maskByByte + _len; if (_fin == 1) { break; } } _packageSize = uint.Parse(_start.ToString()); return(_package); }
public bool Check(byte[] _byteArray, bool _completely = false, SocketSession _session = null) { if (_byteArray.Length < 20) { return(false); } byte[] _lengthArray = new byte[4]; Array.Copy(_byteArray, _lengthArray, 4); if (BitConverter.IsLittleEndian) { Array.Reverse(_lengthArray); } int _packageSize = BitConverter.ToInt32(_lengthArray, 0); if (_byteArray.Length < _packageSize) { return(false); } string _key = ""; if (_session == null) { _key = this.socketRxKey == "" ? this.socketKey : this.socketRxKey; } else { _key = (_session["RxKey"] + "") == "" ? this.socketKey : (_session["RxKey"] + ""); } if (_key == "") { throw new Exception("DePackage failed: RxKey is empty."); } byte[] _checkArray = new byte[_packageSize - 16]; Array.Copy(_byteArray, _checkArray, _checkArray.Length); string _check = System.Text.Encoding.UTF8.GetString(MD5.Encode2ByteArray(_checkArray)); byte[] _md5Array = new byte[16]; Array.Copy(_byteArray, _packageSize - 16, _md5Array, 0, 16); string _md5 = System.Text.Encoding.UTF8.GetString(_md5Array); if (_session != null && _session.Protocol == null) { try { byte[] _contentArray = new byte[_packageSize - 20]; Array.Copy(_byteArray, 4, _contentArray, 0, _contentArray.Length); string _decoded = System.Text.Encoding.UTF8.GetString(DES.Decode2ByteArray(_contentArray, _key, System.Security.Cryptography.CipherMode.CBC)); JObject _json = JObject.Parse(_decoded); return(true); } catch { return(false); } } else { return(_check == _md5); } }
/// <summary> /// 数据打包 /// </summary> /// <param name="_objects">需要打包的对象</param> /// <returns>打包后的数据</returns> public byte[] EnPackage(object _object, SocketSession _session = null) { if (_object == null) { return(new byte[0]); } LztpPackage _package = (LztpPackage)_object; if (_package.TimestampSend == 0) { _package.TimestampSend = this.GetTimestamp(DateTime.UtcNow); } else { _package.TimestampResponse = this.GetTimestamp(DateTime.UtcNow); } MemoryStream _body_stream = new MemoryStream(); byte[] _body_Fields = new byte[_package.Fields.Length]; #region Body_Fields,Body_Content for (int i = 0; i < _package.Fields.Length; i++) { _body_Fields[i] = this.AppendToByteArray(ref _body_stream, _package.Fields[i]); } byte[] _body_Content = _body_stream.ToArray(); _body_stream.Close(); #endregion byte[] _body_Header = new byte[13 + _body_Fields.Length]; #region Body_Header _body_Header[0] = 0x00; Array.Copy(this.UInt32ToByteArray(UInt32.Parse(_body_Content.Length.ToString())), 0, _body_Header, 1, 4); Array.Copy(this.UInt32ToByteArray(this.GetCRC32(_body_Content)), 0, _body_Header, 5, 4); Array.Copy(this.UInt32ToByteArray(UInt32.Parse(_package.Fields.Length.ToString())), 0, _body_Header, 9, 4); Array.Copy(_body_Fields, 0, _body_Header, 13, _body_Fields.Length); #endregion byte[] _packageArray = new byte[64 + _body_Header.Length + _body_Content.Length]; byte[] _head_Content = new byte[60]; #region Head_Content Array.Copy(this.Head, 0, _head_Content, 0, 4); Array.Copy(this.UInt32ToByteArray(_package.Version), 0, _head_Content, 4, 4); Array.Copy(this.UInt32ToByteArray(UInt32.Parse(_packageArray.Length.ToString())), 0, _head_Content, 8, 4); Array.Copy(this.UInt32ToByteArray(this.GetCRC32(_body_Header)), 0, _head_Content, 12, 4); Array.Copy(this.UInt16ToByteArray(_package.Command1), 0, _head_Content, 16, 2); Array.Copy(this.UInt16ToByteArray(_package.Command2), 0, _head_Content, 18, 2); Array.Copy(this.UInt32ToByteArray(_package.CommandId), 0, _head_Content, 20, 4); Array.Copy(this.DoubleToByteArray(_package.TimestampSend), 0, _head_Content, 24, 8); Array.Copy(this.DoubleToByteArray(_package.TimestampReceive), 0, _head_Content, 32, 8); Array.Copy(this.DoubleToByteArray(_package.TimestampResponse), 0, _head_Content, 40, 8); for (int i = 48; i < 60; i++) { _head_Content[i] = 0x0; } #endregion byte[] _head_CRC32 = new byte[4]; #region Head_CRC32 Array.Copy(this.UInt32ToByteArray(this.GetCRC32(_head_Content)), 0, _head_CRC32, 0, 4); #endregion Array.Copy(_head_Content, 0, _packageArray, 0, _head_Content.Length); Array.Copy(_head_CRC32, 0, _packageArray, _head_Content.Length, _head_CRC32.Length); Array.Copy(_body_Header, 0, _packageArray, _head_Content.Length + _head_CRC32.Length, _body_Header.Length); Array.Copy(_body_Content, 0, _packageArray, _head_Content.Length + _head_CRC32.Length + _body_Header.Length, _body_Content.Length); return(_packageArray); }
internal void EndReceive(SocketAsyncEventArgs _socketAsyncEventArgs) { try { bool _disconnect = false; if (_socketAsyncEventArgs == null || _socketAsyncEventArgs.SocketError != SocketError.Success || _socketAsyncEventArgs.BytesTransferred <= 0 || _shutingdown) { _disconnect = true; } SocketSession _socketSession = (SocketSession)_socketAsyncEventArgs.UserToken; if (!_disconnect) { try { #region 读取数据 _socketSession.ReceivedStream.Write(_socketAsyncEventArgs.Buffer, _socketAsyncEventArgs.Offset, _socketAsyncEventArgs.BytesTransferred); byte[] _receivedBytes = _socketSession.ReceivedStream.ToArray(); if (_receivedBytes == null) { _disconnect = true; } try { this.OnReceive(_socketSession, _receivedBytes); } catch (Exception _ex) { this.OnException(_ex); _disconnect = true; } _socketSession.LastOperationTime = DateTime.UtcNow; #endregion #region 匹配协议 if (_socketSession.Protocol == null) { for (int i = 0; i < this.Protocols.Length; i++) { if (this.Protocols[i].Check(_receivedBytes, false, _socketSession)) { _socketSession.Protocol = this.Protocols[i]; break; } } } #endregion #region 处理数据包 if (_socketSession.Protocol != null) { while (_receivedBytes != null && _socketSession.Protocol.Check(_receivedBytes, false, _socketSession)) { uint _packageSize = 0; object _package = _socketSession.Protocol.DePackage(_receivedBytes, out _packageSize, false, _socketSession); if (_package == null) { throw new Exception("Package is NULL."); } #region OnReceivingPackage 事件处理 try { this.OnReceivingPackage(_socketSession, _package); } catch (Exception _ex) { this.OnException(_ex); } #endregion if (!_socketSession.Protocol.Check(_receivedBytes, true, _socketSession)) { break; } _packageSize = 0; _package = _socketSession.Protocol.DePackage(_receivedBytes, out _packageSize, true, _socketSession); if (_package == null) { throw new Exception("Package is NULL."); } #region 刷新已接受数据流 byte[] _temp = new byte[_socketSession.ReceivedStream.Length - _packageSize]; if (_temp.Length > 0) { _socketSession.ReceivedStream.Position = _packageSize; _socketSession.ReceivedStream.Read(_temp, 0, _temp.Length); _socketSession.ReceivedStream.Position = 0; _socketSession.ReceivedStream.Write(_temp, 0, _temp.Length); _socketSession.ReceivedStream.SetLength(_temp.Length); _socketSession.ReceivedStream.Capacity = _temp.Length; _receivedBytes = _socketSession.ReceivedStream.ToArray(); } else { _socketSession.ReceivedStream.SetLength(0); _socketSession.ReceivedStream.Capacity = 0; _receivedBytes = new byte[0]; } #endregion #region OnReceivedPackage 事件处理 try { if (_socketSession.Protocol.IsKeepAlivePackage(_package, _socketSession)) { _socketSession.SendPackage(_socketSession.Protocol.KeepAlivePackage); } else { this.OnReceivedPackage(_socketSession, _package); } } catch (Exception _ex) { this.OnException(_ex); } #endregion } } #endregion this.BeginReceive(_socketAsyncEventArgs); return; } catch (Exception _ex) { Console.WriteLine(_ex); _disconnect = true; } } if (_disconnect) { this.BeginDisconnect(_socketAsyncEventArgs.AcceptSocket); this.OnSessionEnd(_socketSession); this.bufferManager.FreeBuffer(_socketAsyncEventArgs); _socketSession.Clear(); } } catch (Exception _ex) { this.OnException(_ex); } }
public object DePackage(byte[] _byteArray, out uint _packageSize, bool _completely = false, SocketSession _session = null) { string _data = Encoding.UTF8.GetString(_byteArray); int _index = _data.IndexOf('\n'); _packageSize = uint.Parse((_index + 1).ToString()); if (_index <= -1) { return(null); } try { string _source = _data.Substring(0, _index); return(JObject.Parse(OpenSSLAes.Decode(_source, this.key))); } catch { return(null); } }
/// <summary> /// 实现接口:是否是一个完整的包 /// </summary> /// <param name="_byteArray">检查的数据流</param> /// <param name="_completely">是否完全检查数据包</param> /// <returns>是否检测成功</returns> public bool Check(byte[] _byteArray, bool _completely, SocketSession _session = null) { // 检查读取头大小 if (_byteArray == null || _byteArray.Length < 64) { return(false); } if (_byteArray[0] != this.Head[0] || _byteArray[1] != this.Head[1] || _byteArray[2] != this.Head[2] || _byteArray[3] != this.Head[3]) { return(false); } // 读取头部信息 byte[] _packageHeader = new byte[64]; Array.Copy(_byteArray, 0, _packageHeader, 0, 64); byte[] _packageLengthArray = new byte[4]; Array.Copy(_packageHeader, 8, _packageLengthArray, 0, 4); uint _packageLength = this.ByteArrayToUInt32(_packageLengthArray); byte[] _packageHeaderCRC32 = new byte[4]; Array.Copy(_packageHeader, 60, _packageHeaderCRC32, 0, 4); // 检查头部CRC32 byte[] _packageHeaderContent = new byte[60]; Array.Copy(_packageHeader, 0, _packageHeaderContent, 0, 60); if (this.GetCRC32(_packageHeaderContent) != this.ByteArrayToUInt32(_packageHeaderCRC32)) { return(false); } // 检查数据头CRC32 try { if (_completely && _packageLength > uint.Parse("64")) { if (uint.Parse(_byteArray.Length.ToString()) < _packageLength) { return(false); } byte _packageBodyType = _byteArray[64]; byte[] _packageBodyLengthArray = new byte[4]; Array.Copy(_byteArray, 65, _packageBodyLengthArray, 0, 4); uint _packageBodyLength = this.ByteArrayToUInt32(_packageBodyLengthArray); byte[] _packageBodyCRC32Array = new byte[4]; Array.Copy(_byteArray, 69, _packageBodyCRC32Array, 0, 4); uint _packageBodyCRC32 = this.ByteArrayToUInt32(_packageBodyCRC32Array); byte[] _packageBodyFieldCountArray = new byte[4]; Array.Copy(_byteArray, 73, _packageBodyFieldCountArray, 0, 4); uint _packageBodyFieldCount = this.ByteArrayToUInt32(_packageBodyFieldCountArray); byte[] _packageBodyArray = new byte[_packageBodyLength]; Array.Copy(_byteArray, (long)(77 + _packageBodyFieldCount), _packageBodyArray, 0, _packageBodyLength); if (this.GetCRC32(_packageBodyArray) != _packageBodyCRC32) { return(false); } } return(true); } catch { return(false); } }
public object DePackage(byte[] _byteArray, out uint _packageSize, bool _completely, SocketSession _session = null) { if (!this.Check(_byteArray, _completely, _session)) { throw new Exception("Can not depackage this stream."); } string _key = ""; if (_session == null) { _key = this.socketRxKey == "" ? this.socketKey : this.socketRxKey; } else { _key = (_session["RxKey"] + "") == "" ? this.socketKey : (_session["RxKey"] + ""); } if (_key == "") { throw new Exception("DePackage failed: RxKey is empty."); } byte[] _lengthArray = new byte[4]; Array.Copy(_byteArray, _lengthArray, 4); if (BitConverter.IsLittleEndian) { Array.Reverse(_lengthArray); } _packageSize = BitConverter.ToUInt32(_lengthArray, 0); try { byte[] _contentArray = new byte[_packageSize - 20]; Array.Copy(_byteArray, 4, _contentArray, 0, _contentArray.Length); string _decoded = System.Text.Encoding.UTF8.GetString(DES.Decode2ByteArray(_contentArray, _key, System.Security.Cryptography.CipherMode.CBC)); JObject _json = JObject.Parse(_decoded); return(_json); } catch { return(null); } }
/// <summary> /// 数据解包 /// </summary> /// <param name="_byteArray">解包的数据流</param> /// <param name="_packageSize">输出数据包整体大小</param> /// <returns>解包后的对象</returns> public object DePackage(byte[] _byteArray, out uint _packageSize, bool _completely, SocketSession _session = null) { if (!this.Check(_byteArray, _completely)) { throw new Exception("Can not depackage this stream."); } LztpPackage _package = new LztpPackage(); byte[] _packageHeader = new byte[64]; Array.Copy(_byteArray, 0, _packageHeader, 0, 64); byte[] _packageVersion = new byte[4]; Array.Copy(_packageHeader, 4, _packageVersion, 0, 4); byte[] _packageLength = new byte[4]; Array.Copy(_packageHeader, 8, _packageLength, 0, 4); byte[] _packageBodyCRC32 = new byte[4]; Array.Copy(_packageHeader, 12, _packageBodyCRC32, 0, 4); byte[] _packageCommand1 = new byte[2]; Array.Copy(_packageHeader, 16, _packageCommand1, 0, 2); byte[] _packageCommand2 = new byte[2]; Array.Copy(_packageHeader, 18, _packageCommand2, 0, 2); byte[] _packageCommandId = new byte[4]; Array.Copy(_packageHeader, 20, _packageCommandId, 0, 4); byte[] _packageTimestampSend = new byte[8]; Array.Copy(_packageHeader, 24, _packageTimestampSend, 0, 8); byte[] _packageTimestampReceive = new byte[8]; Array.Copy(_packageHeader, 32, _packageTimestampReceive, 0, 8); byte[] _packageTimestampResponse = new byte[8]; Array.Copy(_packageHeader, 40, _packageTimestampResponse, 0, 8); byte[] _packageHeaderCRC32 = new byte[4]; Array.Copy(_packageHeader, 60, _packageHeaderCRC32, 0, 4); _package.Version = this.ByteArrayToUInt32(_packageVersion); _package.Length = this.ByteArrayToUInt32(_packageLength); _package.BodyHeadCRC32 = this.ByteArrayToUInt32(_packageBodyCRC32); _package.Command1 = this.ByteArrayToUInt16(_packageCommand1); _package.Command2 = this.ByteArrayToUInt16(_packageCommand2); _package.CommandId = this.ByteArrayToUInt32(_packageCommandId); _package.TimestampSend = this.ByteArrayToDouble(_packageTimestampSend); _package.TimestampReceive = this.GetTimestamp(DateTime.Now); _package.TimestampResponse = this.ByteArrayToDouble(_packageTimestampResponse); _package.HeadCRC32 = this.ByteArrayToUInt32(_packageHeaderCRC32); _package.BodyType = new byte(); _package.BodyLength = 0; _package.BodyCRC32 = 0; _package.FieldCount = 0; _package.Fields = new object[0]; _package.FieldTypes = new byte[0]; _package.ReceivedLength = _byteArray.Length - 64; if (_package.ReceivedLength > _package.Length - 64) { _package.ReceivedLength = int.Parse(_package.Length.ToString()) - 64; } if (_completely && _package.Length > 64) { _package.BodyType = _byteArray[64]; //string _byteString = ""; //for (int i = 0; i < _byteArray.Length; i++) //{ // _byteString += i > 0 && i % 8 == 0 ? "\n" : ""; // _byteString += _byteArray[i].ToString("X2") + " "; //} if (_package.BodyType == 0x00) { #region 0x00 数据包 byte[] _bodyLength = new byte[4]; Array.Copy(_byteArray, 65, _bodyLength, 0, 4); _package.BodyLength = this.ByteArrayToUInt32(_bodyLength); byte[] _bodyCRC32 = new byte[4]; Array.Copy(_byteArray, 69, _bodyCRC32, 0, 4); _package.BodyCRC32 = this.ByteArrayToUInt32(_bodyCRC32); byte[] _fieldCount = new byte[4]; Array.Copy(_byteArray, 73, _fieldCount, 0, 4); _package.FieldCount = this.ByteArrayToUInt32(_fieldCount); byte[] _fieldTypes = new byte[_package.FieldCount]; Array.Copy(_byteArray, 77, _fieldTypes, 0, _fieldTypes.Length); _package.FieldTypes = _fieldTypes; if (_package.FieldCount != _package.FieldTypes.Length) { throw new Exception("Field count and type length not match."); } if (_package.FieldCount > 100000) { throw new Exception("Field count can not more then 100000."); } _package.Fields = new object[_package.FieldCount]; uint _position = 77 + (uint)_package.FieldTypes.Length; uint _fieldSize = 0; for (UInt32 i = 0; i < _fieldTypes.Length; i++) { _package.Fields[i] = this.GetFromByteArray(_byteArray, _position, _package.FieldTypes[i], ref _fieldSize); _position += _fieldSize; } #endregion } else if (_package.BodyType == 0x01) { _packageSize = 0; } } _packageSize = _package.Length; return(_package); }
public bool Check(byte[] _byteArray, bool _completely = false, SocketSession _session = null) { return(this.DePackage(_byteArray, out uint _package) != null); }