/// <summary> /// 모든 클라한테 전송 /// </summary> public void Broadcast(INetworkPacket packet) { foreach (NetworkClient client in ConnectedClients.Values) { SendTo(client, packet); } }
/// <summary> /// 모든 클라한테 전송 /// </summary> /// <param name="packet">전송하는 패킷</param> /// <param name="except">제외할 클라들</param> public void BroadcastExcept(INetworkPacket packet, NetworkClient[] except) { foreach (NetworkClient client in ConnectedClients.Values.Except(except)) { SendTo(client, packet); } }
public Task SendAsync(INetworkPacket package) { if (package == null) { throw new ArgumentNullException(nameof(package)); } if (_serializer == null) { throw new NullReferenceException(nameof(_serializer)); } if (_serialPort == null) { throw new NullReferenceException(nameof(_serialPort)); } if (!_serialPort.IsOpen) { throw new Exception("Serial port is not open."); } using (var stream = new MemoryStream()) { var length = _serializer.Serialize(package, stream); _serialPort.Write(stream.ToArray(), 0, length); return(Task.CompletedTask); } }
public void OnReceivePacket(NetworkClient client, INetworkPacket packet) { if (packet.GetType() == typeof(PtkClientConnect)) { lock (_ConnectWaitingClientLocker) { if (_ConnectWaitingClient.Contains(client)) { _ConnectWaitingClient.Remove(client); } } lock (ConnectedClientsLocker) { if (ConnectedClients.ContainsKey(packet.ID)) { ConnectedClients[packet.ID] = client; } else { ConnectedClients.Add(packet.ID, client); } } } _TcpReceivePacketStreamer.RegisterPacket(packet.ID, packet); }
public int Serialize(INetworkPacket packet, BinaryWriter writer) { if (packet == null) { throw new ArgumentNullException(nameof(packet)); } if (writer == null) { throw new ArgumentNullException(nameof(writer)); } switch (packet) { case AckFrame ackFrame: return(Serialize(ackFrame, writer)); case ShortFrame shortFrame: return(Serialize(shortFrame, writer)); case LongFrame longFrame: return(Serialize(longFrame, writer)); case ControlFrame controlFrame: return(Serialize(controlFrame, writer)); default: throw new NotImplementedException(); } }
private void OnReceivePacket() { while (Connected) { int readBytesCount = 0; try { readBytesCount = _Stream.Read(_ReciveBytes, 0, _ReciveBytes.Length); } catch { NetworkServer.Get().Disconnect(this); } if (readBytesCount > 0) { INetworkPacket networkPacket = _ReciveBytes.ToNetworkPacket(); NetworkServer.Get().OnReceivePacket(this, networkPacket); } else { break; } } NetworkServer.Get().Disconnect(this); }
public void RegisterPacket(long id, INetworkPacket packet) { _PackerProcesser.Enqueue(new NetworkPacketPair() { ID = id, Packet = packet }); }
public void BroadcastExcept(INetworkPacket packet, long[] except) { foreach (NetworkClient client in ConnectedClients.Values.Where(x => !except.Contains(x.ID))) { SendTo(client, packet); } }
public void Proccess(NetworkClient client, INetworkPacket packet) { if (_PacketMap.TryGetValue(packet.GetType(), out Action <NetworkClient, INetworkPacket> func)) { func(client, packet); } }
private static ArchitectureAttribute GetArchitectureFromPacket(INetworkPacket packet) { return(packet .GetType() .GetCustomAttributes(typeof(ArchitectureAttribute), false) .OfType <ArchitectureAttribute>() .FirstOrDefault()); }
public int Serialize(INetworkPacket packet, BinaryWriter writer) { var queryPackage = packet as QueryPacket; writer.Write(queryPackage.Data); return(queryPackage.Data.Length); }
public static byte[] ToByteArray(this INetworkPacket packet) { BinaryFormatter formatter = new BinaryFormatter(); MemoryStream Stream = new MemoryStream(); formatter.Serialize(Stream, packet); return(Stream.ToArray()); }
public void OnInitialDataReceived(Player player, INetworkPacket data) { var credentials = (LoginCredentials)data; Debug.Log(credentials.Username + " has connected!"); CreatePlayer(player, credentials); }
protected WebModel.INetworkPacket CreateNetworkPacket(WebModel.IEntity entity, Uri uri) { INetworkPacket packet = NetworkModel.Factory.CreateObject <INetworkPacket>(); packet.Source = uri; packet.TypeIdentifier = entity.GetType().GUID; packet.Entity = Mapper.MapWebModelToDataModelEntities(entity); return(new NetworkPacket(packet, Serializer)); }
public static bool CanServerReceive(this INetworkPacket packet) { ArchitectureAttribute attrib = GetArchitectureFromPacket(packet); if (attrib == null) { throw new Exception($"NetworkPacket[ID:{packet.GetPacketNumber()}] doesn't specify a packet architecture."); } return(attrib.Architecture.HasFlag(PacketArchitecture.ClientToServer)); }
private async Task ReceiveWorker(CancellationToken cancellationToken) { Microsoft.Azure.Devices.Client.Message message = null; INetworkPacket packet = null; while (!cancellationToken.IsCancellationRequested) { try { message = await _device.Receive(); if (message == null) { continue; } var messageType = MessageType.PULL_RESP;// Enum.Parse(typeof(MessageType), message.Properties["MessageType"]); var data = message.GetBytes(); _logger.Info($"Receiving '{messageType}' packet from IoT Hub by deviceid '{_deviceId}'", GetType().Name); switch (messageType) { case MessageType.PULL_RESP: { packet = new PullRespPacket { ProtocolVersion = int.Parse(message.Properties["ProtocolVersion"]), //Token = message.Properties["Token"], Payload = _payloadSerializer.Deserialize <PullRespPacketPayload>(data), }; } break; default: { continue; } } PacketReceived(this, new PacketEventArgs(packet, this)); } catch (BrokenCircuitException ex) { _logger.Error($"Circuit breaker open -> An error occured while receiving a message from IoT Hub by deviceid '{_deviceId}'", GetType().Name, ex); await Task.Delay(TimeSpan.FromSeconds(30)); } catch (Exception ex) { _logger.Error($"An error occured while receiving a message from IoT Hub by deviceid '{_deviceId}'", GetType().Name, ex); } } }
public void Proccess(INetworkPacket packet) { if (_PacketMap.TryGetValue(packet.GetType(), out Action <INetworkPacket> func)) { func(packet); } else { Debug.LogError(packet.GetType() + " 메시지가 도착함 해당 패킷에 대한 기능이 패킷 맵에 등록되어 있지 않아요!"); } }
public bool CanPlayerAuth(INetworkPacket data) { var credentials = (LoginCredentials)data; if (credentials.ServerVersion < _serverVersion) { return(false); } return(true); }
public static INetworkPacket ToNetworkPacket(this byte[] bytes) { BinaryFormatter formatter = new BinaryFormatter(); MemoryStream Stream = new MemoryStream(); Stream.Write(bytes, 0, bytes.Length); Stream.Seek(0, SeekOrigin.Begin); INetworkPacket clientInfo = (INetworkPacket)formatter.Deserialize(Stream); return(clientInfo); }
// ========================================================================== // #region Private private void SendPacket(Class_SessionDerived pSessionRecv, byte[] arrByte, INetworkPacket pPacket, int iPort, bool bIsReliableResend = false) { IPEndPoint pSendIP = new IPEndPoint(IPAddress.Parse(pSessionRecv.p_strIP), iPort); _pClientUDP_Send.Send(arrByte, arrByte.Length, pSendIP); INetworkPacket_Reliable pPacketIsReliable = pPacket as INetworkPacket_Reliable; if (bIsReliableResend == false && pPacketIsReliable != null) { pSessionRecv.DoAddReliablePacket(pPacketIsReliable, arrByte, iPort); } }
public int Serialize(INetworkPacket packet, Stream stream) { if (packet == null) { throw new ArgumentNullException(nameof(packet)); } if (stream == null) { throw new ArgumentNullException(nameof(stream)); } return(Serialize(packet, new BinaryWriter(stream))); }
private async Task SendWorker(CancellationToken cancellationToken) { INetworkPacket networkPacket = null; while (!cancellationToken.IsCancellationRequested) { try { if (!_queue.TryDequeue(out networkPacket)) { //await Task.Delay(100); continue; } var correlationId = Guid.NewGuid(); switch (networkPacket) { case PushDataPacket pushDataPacket: { var data = _payloadSerializer.Serialize(pushDataPacket.Payload); var message = new Microsoft.Azure.Devices.Client.Message(data); message.CorrelationId = correlationId.ToString(); message.Properties["EventId"] = correlationId.ToString(); message.Properties["CorrelationId"] = correlationId.ToString(); message.Properties["DeviceId"] = pushDataPacket.Eui; message.Properties["ProtocolName"] = "Lora Packet Forwarder"; message.Properties["ProtocolVersion"] = pushDataPacket.ProtocolVersion.ToString(); message.Properties["MessageType"] = pushDataPacket.MessageType.ToString(); message.CreationTimeUtc = DateTime.UtcNow; _logger.Info($"Sending PushDataPacket to IoT Hub by deviceid '{_deviceId}'", GetType().Name); await _device.Send(message); } break; } } catch (BrokenCircuitException ex) { _logger.Error($"Circuit breaker open -> An error occured while sending a message to IoT Hub by deviceid '{_deviceId}'. Discarding message", GetType().Name, ex); } catch (Exception ex) { _logger.Error($"An error occured while sending a message to IoT Hub by deviceid '{_deviceId}'", GetType().Name, ex); } } }
public static INetworkPacket Deserialize(byte[] source, ISerializer <INetworkPacket> serializer) { ISerializer <Entity> entitySerializer = new Serializer <Entity>(serializer.Encoding, serializer.Formatter.Format); (int separatorStartIndex, int separatorEndIndex) = GetEntitySeparatorRange(source, serializer); Span <byte> entityBytes = source.AsSpan(separatorEndIndex, source.Length - separatorEndIndex); Span <byte> networkEntityBytes = source.AsSpan(0, separatorStartIndex == -1 ? source.Length : separatorStartIndex); INetworkPacket entity = serializer.Deserialize(networkEntityBytes.ToArray()); if (separatorStartIndex != -1) { entity.Entity = entitySerializer.Deserialize(entityBytes.ToArray()); } return(entity); }
private byte[] CombineBuffer_Header_And_Packet(INetworkPacket pPacket, byte[] arrByte) { bool bIsGenerate; Packet_Header pPacketHeader; OnGeneratePacketHeader(pPacket, out bIsGenerate, out pPacketHeader); _pBufferSend.Clear(); if (bIsGenerate) { pPacketHeader.INetworkPacketHeader_Set_Header(arrByte.Length, pPacket.INetworkPacket_Get_PacketID()); _pBufferSend.Enqueue(ByteExtension.ConvertByteArray(pPacketHeader)); } _pBufferSend.Enqueue(ByteExtension.ConvertByteArray(pPacket)); return(_pBufferSend.Dequeue_OrNull(_pBufferSend.Count)); }
public bool SendEntity(INetworkPacket packet, Func <INetworkPacket, byte[]> serializer) { foreach ((Memory <byte> chunk, bool last) in SplitObjectIntoBufferSizedChunks(packet, serializer)) { chunk.CopyTo(_buffer.Array.AsMemory()); try { _wsContext.WebSocket?.SendAsync(_buffer, WebSocketMessageType.Binary, last, _token); } catch (WebSocketException ex) { _wsContext.WebSocket?.CloseAsync(WebSocketCloseStatus.InternalServerError, ex.Message, _token); return(false); } } return(true); }
public Task SendAsync(INetworkPacket package) { if (package == null) { throw new ArgumentNullException(nameof(package)); } if (_socket == null) { throw new NullReferenceException(nameof(_socket)); } if (_serializer == null) { throw new NullReferenceException(nameof(_serializer)); } if (_endpoint == null) { throw new NullReferenceException(nameof(_endpoint)); } using (var stream = new MemoryStream()) { var length = _serializer.Serialize(package, stream); var state = new OrderedAsyncState(); state.Client = _socket; state.ReadEventArgs.RemoteEndPoint = _endpoint; state.ReadEventArgs.SetBuffer(stream.ToArray(), 0, length); state.ReadEventArgs.AcceptSocket = _socket; state.ReadEventArgs.UserToken = state; state.ReadEventArgs.Completed += OnCompleted; state.ReceiveAsync = e => { var receiveBuffer = new byte[MAX_BUFFER_SIZE]; e.SetBuffer(receiveBuffer, 0, receiveBuffer.Length); return(e.AcceptSocket.ReceiveAsync(e)); }; var result = _socket.SendToAsync(state.ReadEventArgs); return(Task.CompletedTask); } }
public void SendMessage(PacketDeliveryMethod method, INetworkPacket packet, string accountName) { if (!_usernameToConnection.ContainsKey(accountName)) { return; } NetConnection recipient = _usernameToConnection[accountName]; NetOutgoingMessage message = _server.CreateMessage(); MemoryStream stream = new MemoryStream(); Serializer.Serialize(stream, packet); message.Write(stream.ToArray()); // This may seem redundant but I am protecting against the possibility that // Lidgren is vaporware. Should we need to swap out the network code in the future, // only this class will need to be touched. NetDeliveryMethod deliveryMethod = NetDeliveryMethod.Unreliable; switch (method) { case PacketDeliveryMethod.Unreliable: deliveryMethod = NetDeliveryMethod.Unreliable; break; case PacketDeliveryMethod.UnreliableSequenced: deliveryMethod = NetDeliveryMethod.UnreliableSequenced; break; case PacketDeliveryMethod.ReliableUnordered: deliveryMethod = NetDeliveryMethod.ReliableUnordered; break; case PacketDeliveryMethod.ReliableSequenced: deliveryMethod = NetDeliveryMethod.ReliableSequenced; break; case PacketDeliveryMethod.ReliableOrdered: deliveryMethod = NetDeliveryMethod.ReliableOrdered; break; } _server.SendMessage(message, recipient, deliveryMethod); }
public void SendMessage(PacketDeliveryMethod method, INetworkPacket packet) { if (_serverConnection == null || _serverConnection.Status != NetConnectionStatus.Connected) { throw new Exception("Client is not currently connected to a server."); } NetOutgoingMessage message = _client.CreateMessage(); MemoryStream stream = new MemoryStream(); Serializer.Serialize(stream, packet); message.Write(stream.ToArray()); // This may seem redundant but I am protecting against the possibility that // Lidgren is vaporware. Should we need to swap out the network code in the future, // only this class will need to be touched. NetDeliveryMethod deliveryMethod = NetDeliveryMethod.Unreliable; switch (method) { case PacketDeliveryMethod.Unreliable: deliveryMethod = NetDeliveryMethod.Unreliable; break; case PacketDeliveryMethod.UnreliableSequenced: deliveryMethod = NetDeliveryMethod.UnreliableSequenced; break; case PacketDeliveryMethod.ReliableUnordered: deliveryMethod = NetDeliveryMethod.ReliableUnordered; break; case PacketDeliveryMethod.ReliableSequenced: deliveryMethod = NetDeliveryMethod.ReliableSequenced; break; case PacketDeliveryMethod.ReliableOrdered: deliveryMethod = NetDeliveryMethod.ReliableOrdered; break; } _client.SendMessage(message, deliveryMethod); }
private async Task ReadEntity(ArraySegment <byte> buffer, CancellationToken token) { List <byte> receivedBytes = new List <byte>(BUFFER_SIZE); WebSocketReceiveResult response; do { response = await _webSocket?.ReceiveAsync(buffer, token); receivedBytes.AddRange(buffer); }while (!response.EndOfMessage); int endIndex = receivedBytes.LastIndexOf(0x03); if (endIndex > 0) { receivedBytes.RemoveRange(endIndex, receivedBytes.Count - endIndex); } INetworkPacket networkEntity = AbstractNetworkPacket.Deserialize(receivedBytes.ToArray(), Serializer); InvokeEntityChanged(networkEntity.Entity as IEntity); }
private static IEnumerable <(Memory <byte> chunk, bool last)> SplitObjectIntoBufferSizedChunks( INetworkPacket entity, Func <INetworkPacket, byte[]> serializer) { byte[] fullArray = serializer.Invoke(entity); int chunksCount = (int)Math.Ceiling((decimal)fullArray.Length / BUFFER_SIZE); byte[] appendedArray = new byte[chunksCount * BUFFER_SIZE]; Memory <byte> memory = appendedArray.AsMemory(); fullArray.CopyTo(memory); if (fullArray.Length != memory.Length) { appendedArray[fullArray.Length] = 0x03; } for (int i = 0; i < chunksCount; ++i) { bool lastChunk = i == chunksCount - 1; yield return(memory.Slice(i * BUFFER_SIZE, BUFFER_SIZE), lastChunk); } }