public async Task Delete(NewPacket packet)
{
_logger.LogDebug("Delete request, deleting: {@NewPacket}", packet);
var collection = GetNewPacketCollection();
var filter = Builders <NewPacket> .Filter.Eq("ReceivedPacket", packet.Uplink);
await collection.DeleteOneAsync(filter);
}
public async Task EnqueueToStorage(NewPacket packet)
{
var storagePacket = new QueueTypes.Queues.Storages.Storage {
Packet = MapUplinkToQueueType(packet)
};
_logger.Information("Publishing storage notification {@Notification}", storagePacket);
await _bus.PubSub.PublishAsync(storagePacket, handler => handler.WithTopic(nameof(QueueTypes.Queues.Storages.Storage)));
}
/// <summary>
/// Асинхронный запуск сервера
/// </summary>
/// <returns></returns>
public Task StartAsync()
{
return(Task.Factory.StartNew(() =>
{
try
{
if (MessageEncryptionEnabled)
{
Console.WriteLine($"Server run on {Port} with encryption channel");
}
else
{
Console.WriteLine($"Server run on {Port}");
}
_listener.Start();
while (true)
{
TcpClient client = _listener.AcceptTcpClient();
Task.Factory.StartNew(() =>
{
var fluffyClient = new FluffyClient(client, this);
AddConnectedClient(fluffyClient);
StoreInit?.Invoke(fluffyClient);
NewClientConnected?.Invoke(fluffyClient);
fluffyClient.Disconnected += client1 => { ClientDisconnected?.Invoke(client1); };
fluffyClient.NewData += (data) =>
{
NewData?.Invoke(fluffyClient, data);
};
fluffyClient.NewPacket += (ref int id, PacketParser <Packet> parser, FluffyClient xFuffyClient) =>
{
NewPacket?.Invoke(ref id, parser, xFuffyClient);
};
});
}
}
catch (Exception e)
{
Console.WriteLine(e.Message + " " + e.StackTrace);
}
}));
}
public async Task <ActionResult> Delete(NewPacket packet)
{
try
{
await _database.Delete(packet);
return(Ok());
}
catch (Exception e)
{
_logger.LogError("Failed to delete object {@Object} with error {@Exception}", packet, e.Message);
return(Conflict());
}
}
public async Task EnqueueToUplink(NewPacket packet)
{
QueueTypes.Queues.Uplinks.Uplink uplinkPacket = null;
if (packet.PacketType == "rxpk")
{
uplinkPacket = new QueueTypes.Queues.Uplinks.Uplink
{
PacketType = "rxpk",
isRegistered = packet.RxPacket.isRegesteredDevice,
RxPacket = new QueueTypes.Models.ReceivedPackets.ReceivedPacket
{
metadata = new QueueTypes.Models.ReceivedPackets.ReceivedPacketsMetadata {
Channel = packet.RxPacket.metadata.Channel,
CodingRate = packet.RxPacket.metadata.CodingRate,
Data = packet.RxPacket.metadata.Data,
DataRate = packet.RxPacket.metadata.DataRate,
Frequency = packet.RxPacket.metadata.Frequency,
LuminanceSignalToRatio = packet.RxPacket.metadata.LuminanceSignalToRatio,
Modulation = packet.RxPacket.metadata.Modulation,
Size = packet.RxPacket.metadata.Size,
Timestamp = packet.RxPacket.metadata.Timestamp,
RecievedSignalStrenghtIndicator = packet.RxPacket.metadata.RecievedSignalStrenghtIndicator,
RadioFrequencyChannel = packet.RxPacket.metadata.RadioFrequencyChannel,
Stat = packet.RxPacket.metadata.Stat
}
},
UnalteredPacket = packet.UnalteredPacket
};
}
if (packet.PacketType == "stat")
{
uplinkPacket = new QueueTypes.Queues.Uplinks.Uplink
{
PacketType = "stat",
GsPacket = new QueueTypes.Models.GatewayStatusUpdates.GatewayStatusUpdate
{
OriginalMessage = packet.StatPacket.OriginalMessage
},
UnalteredPacket = packet.UnalteredPacket
};
}
_logger.Information("Publishing uplink notification {@Notification}", uplinkPacket);
await _bus.PubSub.PublishAsync(uplinkPacket, handler => handler.WithTopic(nameof(QueueTypes.Queues.Uplinks.Uplink)));
}
public QueueTypes.Models.NewPacket MapUplinkToQueueType(NewPacket receivedPacket)
{
return(new QueueTypes.Models.NewPacket
{
Uplink = new QueueTypes.Models.ReceivedPackets.ReceivedPacket {
metadata = new QueueTypes.Models.ReceivedPackets.ReceivedPacketsMetadata {
Channel = receivedPacket.RxPacket.metadata.Channel,
CodingRate = receivedPacket.RxPacket.metadata.CodingRate,
DataRate = receivedPacket.RxPacket.metadata.DataRate,
Frequency = receivedPacket.RxPacket.metadata.Frequency,
LuminanceSignalToRatio = receivedPacket.RxPacket.metadata.LuminanceSignalToRatio,
Modulation = receivedPacket.RxPacket.metadata.Modulation,
RadioFrequencyChannel = receivedPacket.RxPacket.metadata.RadioFrequencyChannel,
RecievedSignalStrenghtIndicator = receivedPacket.RxPacket.metadata.RecievedSignalStrenghtIndicator,
Size = receivedPacket.RxPacket.metadata.Size,
Stat = receivedPacket.RxPacket.metadata.Stat,
Timestamp = receivedPacket.RxPacket.metadata.Timestamp,
Data = receivedPacket.RxPacket.metadata.Data
},
isRegistered = receivedPacket.RxPacket.isRegesteredDevice,
decodedPacket = new QueueTypes.Models.DecodedLoraPacket {
PhysicalPayload = new QueueTypes.Models.LoRaWanPacketSections.PhysicalPayload
{
MacHeader = receivedPacket.RxPacket.decodedPacket.PhysicalPayload.MacHeader,
MIC = receivedPacket.RxPacket.decodedPacket.PhysicalPayload.MIC,
MacPayload = new QueueTypes.Models.LoRaWanPacketSections.MacPayload
{
FramePort = receivedPacket.RxPacket.decodedPacket.PhysicalPayload.MacPayload.FramePort,
FramePayload = receivedPacket.RxPacket.decodedPacket.PhysicalPayload.MacPayload.FramePayload,
FrameHeader = new QueueTypes.Models.LoRaWanPacketSections.FrameHeader
{
DeviceAddress = receivedPacket.RxPacket.decodedPacket.PhysicalPayload.MacPayload.FrameHeader.DeviceAddress,
FrameControlOctet = receivedPacket.RxPacket.decodedPacket.PhysicalPayload.MacPayload.FrameHeader.FrameControlOctet,
FrameCounter = receivedPacket.RxPacket.decodedPacket.PhysicalPayload.MacPayload.FrameHeader.FrameCounter,
FrameOptions = receivedPacket.RxPacket.decodedPacket.PhysicalPayload.MacPayload.FrameHeader.FrameOptions
}
}
},
OriginalHexString = receivedPacket.RxPacket.decodedPacket.OriginalHexString
}
}
});
}
private void OnRecieve(IAsyncResult state)
{
EndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
if (!open)
{
return;
}
try
{
ArtNetData recieveState = (ArtNetData)(state.AsyncState);
if (recieveState == null)
{
// Packet was invalid continue receiving
ReceiveArtNet();
}
recieveState.DataLength = EndReceiveFrom(state, ref remoteEndPoint);
// Protect against UDP loopback where we recieve our own packets.
if (LocalEndPoint != remoteEndPoint && recieveState.Valid)
{
LastPacket = DateTime.Now;
var packet = ArtNetPacket.FromData(recieveState);
if (packet == null)
{
ReceiveArtNet();
}
NewPacket?.Invoke(this, new NewPacketEventArgs <ArtNetPacket>((IPEndPoint)remoteEndPoint, packet));
}
}
catch (Exception ex)
{
UnhandledException?.Invoke(this, new UnhandledExceptionEventArgs(ex, false));
}
ReceiveArtNet();
}
public bool Connect()
{
if (_client?.Connected == true)
{
return(true);
}
try
{
_client = new TcpClient();
_client.Connect(_address, _port);
_drs = new DataReceiveService(_client, this);
Task.Factory.StartNew(() =>
{
_drs.Disconnected += client =>
{
Disconnected?.Invoke();
};
_drs.NewData += (data) =>
{
NewData?.Invoke(data);
try
{
object packet = null;
int packetId = BitConverter.ToInt32(data.Take(4).ToArray(), 0);
NewPacket?.Invoke(ref packetId, (t) =>
{
using (MemoryStream ms = new MemoryStream(data.Skip(4).ToArray()))
using (BsonReader reader = new BsonReader(ms))
{
JsonSerializer serializer = new JsonSerializer();
packet = serializer.Deserialize(reader, t);
}
return((Packet)packet);
}, this);
}
catch (Exception e)
{
Console.WriteLine(e.Message + " " + e.StackTrace);
}
};
_drs.Run();
});
var waitPacket = SendPacketAndGetResponse <ConnectionRequest, ConnectionConfig>(new ConnectionRequest());
if (waitPacket?.CryptoEnabled == true)
{
RsaClientSide rsaClientSide = new RsaClientSide();
var publicKey = rsaClientSide.PublicKeyString;
var rsaHandshakeResponse =
SendPacketAndGetResponse <RsaHandshakeRequest, RsaHandshakeResponse>(
new RsaHandshakeRequest()
{
PublicKey = publicKey
});
if (rsaHandshakeResponse == null)
{
throw new Exception();
}
var decryptedData = rsaClientSide.Step2(rsaHandshakeResponse.EncryptedData);
Console.WriteLine($"Receive decrypted AES-256 Key: {Convert.ToBase64String(decryptedData)}");
Aes256Key = decryptedData;
var pinger = new PingService(this);
pinger.StartAsync();
}
else
{
var pinger = new PingService(this);
pinger.StartAsync();
}
}
catch (Exception e)
{
return(false);
}
return(true);
}
/// <summary>
/// Raises an event that indicates a new packet has arrived.
/// </summary>
/// <param name="p">The arrived <see cref="Packet"/>.</param>
protected void OnNewPacket(Packet p)
{
NewPacket?.Invoke(this, p);
}
private void ReceiveDataCallback(IAsyncResult ar)
{
Packets.GenericPacket NewPacket = Packets.NoPacket;
lock (Client)
{
try
{
if (ConnectionContext == ConnectionContexts.Connectionless)
{
return;
}
if (Client.IsDisconnecting())
{
return;
}
if (Client.IsDisconnected())
{
return;
}
// Retrieve the state object and the client socket
// from the asynchronous state object.
SocketReadObject state = (SocketReadObject)ar.AsyncState;
// Read data from the remote device.
int bytesRead = Socket.EndReceive(ar);
if (bytesRead == 0)
{
//End Of Stream
//Debug.WriteLine("End of DataStream");
Client.Disconnect("Recv'd 0 data when trying to receive packet body.");
}
state.bytesreceivedsofar += bytesRead;
if (state.bytesreceivedsofar < state.size)
{
Socket.BeginReceive(state.databuffer, state.bytesreceivedsofar, state.size - state.bytesreceivedsofar, SocketFlags.None,
new AsyncCallback(ReceiveDataCallback), state);
return;
}
else
{
//Debug.WriteLine(state.sizebuffer.ToDebugHexString() + state.databuffer.ToDebugHexString());
//Debug.TestPoint();
// All bytes have been received.
NewPacket = new Packets.GenericPacket(state.sizebuffer.Concat(state.databuffer).ToArray());
//Debug.WriteLine("End Receiving");
}
}
catch (SocketException e)
{
Client.Disconnect("Remote client forcibly closed the connection.");
return;
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
Client.Disconnect("Generic Error when trying to receive packet body.");
return;
}
}
//Outside of lock now, let another receive process begin!
foreach (WaitForPacketObject ThisWaitForPacketObject in WaitForPacketList.ToArray())
{
if (NewPacket == null)
{
break;
}
if (NewPacket == Packets.NoPacket)
{
break;
}
if (NewPacket.GetRawString() == ThisWaitForPacketObject.Packet.GetRawString()) //Must match based on strings, not bytes...
{
//Packets match.
ThisWaitForPacketObject.Trigger.Set(); //Set the trigger...
WaitForPacketList.Remove(ThisWaitForPacketObject); //Remove self.
//ThisWaitForPacketObject.Trigger.Dispose(); //Remove the trigger once set.
//Debug.WriteLine(Client.Username + " End Wait");
}
}
ProcessPacket(NewPacket);
//Thread.Sleep(500);
}
public async Task Create(NewPacket packet)
{
_logger.LogDebug("Create request, creating: {@packet}", packet);
var collection = GetNewPacketCollection();
await collection.InsertOneAsync(packet);
}
private void ReceiveDataStart(int receiveBufferLength)
{
try
{
_disconnectTimer.Stop();
_disconnectTimer.Start();
_disconnectTimer.Elapsed += (sender, args) =>
{
Console.WriteLine("Client disconnected by timeout");
CloseConnect();
};
using (NetworkStream stream = TcpClient.GetStream())
{
while (TcpClient.Connected)
{
if (TcpClient.Available < HeaderLength)
{
Thread.Sleep(5);
continue;
}
int messageLength = ReceiveHeaderData(stream);
if (messageLength > _server.MaxReceivePacketLength)
{
CloseConnect();
return;
}
int remaining = messageLength;
byte[] finalDataBuffer = new byte[messageLength];
int index = 0;
while (remaining > 0)
{
if (remaining < receiveBufferLength)
{
receiveBufferLength = remaining;
}
while (TcpClient.Available < receiveBufferLength)
{
Thread.Sleep(5);
}
byte[] buffer = new byte[receiveBufferLength];
stream.Read(buffer, 0, receiveBufferLength);
for (int i = 0; i < buffer.Length; i++)
{
finalDataBuffer[index++] = buffer[i];
}
remaining -= receiveBufferLength;
}
if (Aes256Key != null)
{
finalDataBuffer = MyAes.DecryptBytes(finalDataBuffer, Aes256Key, MyAes.Iv);
}
Console.WriteLine("Readed from client bytes length " + (finalDataBuffer.Length));
if (ByteArrayCompare(finalDataBuffer, PingData))
{
Send(PongData);
_disconnectTimer.Stop();
_disconnectTimer.Start();
Console.WriteLine("Ping data received " + (messageLength + HeaderLength) + " bytes. Pong data sent");
}
else
{
NewData?.Invoke(finalDataBuffer);
try
{
object packet = null;
int packetId = BitConverter.ToInt32(finalDataBuffer.Take(4).ToArray(), 0);
if (_server.MessageEncryptionEnabled)
{
if (this.Aes256Key == null)
{
if (packetId != -122030 && packetId != -42142)
{
Console.WriteLine("Пришел пакет, который не ожидался");
continue;
}
}
}
NewPacket?.Invoke(ref packetId, (t) =>
{
using (MemoryStream ms = new MemoryStream(finalDataBuffer.Skip(4).ToArray()))
using (BsonReader reader = new BsonReader(ms))
{
JsonSerializer serializer = new JsonSerializer();
packet = serializer.Deserialize(reader, t);
}
return((Packet)packet);
}, this);
}
catch (Exception e)
{
Console.WriteLine(e.Message + " " + e.StackTrace);
}
}
}
}
}
catch (Exception e)
{
// Debug
Console.WriteLine(e.Message + " " + e.StackTrace);
}
finally
{
Disconnected?.Invoke(this);
CloseConnect();
}
}
