public static IUdpTransportMessage ToUdpTransportMessage(this IUdpMessage message, IPAddress address, int port) =>
new UdpTransportMessage
{
Address = address,
Port = port,
Message = message
};
public Task <Embed> Create(IUdpMessage message, Server server)
{
switch (message)
{
case PacketUdpServerResponse r:
{
var embed = new EmbedBuilder
{
Title = $"{r.ServerName}"
};
embed.AddField("Players", $"{r.ClientsOn}/{r.ClientsMax}", true);
embed.AddField("Map Size", $"{r.MapWidth}x{r.MapHeight}", true);
embed.AddField("Year", $"{r.GameDate.ToString()}", true);
embed.AddField("Climate", r.Landscape.Stringify().FirstUpper(), true);
embed.AddField("Map name", r.MapName, true);
embed.AddField("Language", r.Language.Stringify().FirstUpper(), true);
embed.AddField("Server address", $"{server.ServerIp}:{server.ServerPort}", true);
embed.AddField("Password?", r.HasPassword ? "Yes" : "No", true);
embed.WithCurrentTimestamp();
return(Task.FromResult(embed.Build()));
}
}
return(null);
}
private IUdpTransportMessage SendMessage(IUdpMessage message, IPAddress targetAddress, int targetPort, bool waitForResponse)
{
IUdpTransportMessage udpResponse = new UdpTransportMessage {
Address = IPAddress.None, Port = 0, Message = message
};
if (message == null)
{
return(udpResponse);
}
IPEndPoint remoteEndPoint = new(targetAddress, targetPort);
bool isBroadcast = targetAddress == IPAddress.Broadcast;
using (UdpClient client = new(AddressFamily.InterNetwork))
{
if (isBroadcast)
{
logger.LogInformation($"Broadcasting [{message.Text}] to ip:port {remoteEndPoint}");
}
else
{
logger.LogInformation($"Sending [{message.Text}] to ip:port {remoteEndPoint}");
}
string toSend = JsonSerializer.Serialize <UdpMessage>(message as UdpMessage);
logger.LogInformation($"Message: \"{toSend}\"");
byte[] buf = Encoding.UTF8.GetBytes(toSend);
try
{
client.EnableBroadcast = isBroadcast;
client.Send(buf, buf.Length, remoteEndPoint);
client.EnableBroadcast = false;
if (waitForResponse)
{
IPEndPoint responseEndPoint = new(IPAddress.Any, 0);
//Receive blocks thread until message returns
byte[] receivedBytes = client.Receive(ref responseEndPoint);
string receivedString = Encoding.UTF8.GetString(receivedBytes);
var receivedMessage = JsonSerializer.Deserialize <UdpMessage>(receivedString);
udpResponse = receivedMessage.ToUdpTransportMessage(responseEndPoint.Address, responseEndPoint.Port);
logger.LogInformation($"Response from {udpResponse.Address}:{udpResponse.Port} is: {udpResponse.Message.Text}");
}
}
catch (Exception ex)
{
logger.LogError(ex.Message);
}
client.Close();
}
return(udpResponse);
}
public Packet CreatePacket(IUdpMessage message)
{
Packet packet = new Packet();
packet.SendByte((byte)message.MessageType);
packet.PrepareToSend();
return(packet);
}
public void SendToAll(IUdpMessage message)
{
var bytes = _serializer.SerializeMessage(message);
foreach (KeyValuePair <string, ConnectedClient> entry in _connectedClients)
{
_connection.Send(entry.Value.Remote, bytes);
}
}
private void DoWork(object state)
{
string messageText = $"Sending from Udp.TimedSender at {DateTimeOffset.Now}";
logger.LogInformation($"Broadcasting message [{messageText}] to port {speaker.SpeakerConfig.BroadcastPort}");
IUdpMessage message = UdpMessageFactory.CreateUdpMessage(messageText);
IUdpTransportMessage response = speaker.BroadcastWithResponse(message, speaker.SpeakerConfig.BroadcastPort);
logger.LogInformation($"Received response from {response.Address}:{response.Port}: [{response.Message.Text}]");
}
public IActionResult OnPost()
{
logger.LogInformation($"Broadcasting message [{Message}] to port {speaker.SpeakerConfig.BroadcastPort}");
IUdpMessage message = UdpMessageFactory.CreateUdpMessage(Message);
IUdpTransportMessage response = speaker.BroadcastWithResponse(message, speaker.SpeakerConfig.BroadcastPort);
Status = $"Received response from {response.Address}:{response.Port}: [{response.Message.Text}]";
logger.LogInformation(Status);
return(Page());
}
public byte[] SerializeMessage(IUdpMessage message)
{
var writer = new DataWriter();
writer.Write(HEADER_VERIFICATION, false);
var cmdName = message.GetType().Name;
cmdName = cmdName.Substring(0, cmdName.Length - "Message".Length);
writer.Write(cmdName);
message.Serialize(writer);
var bytes = writer.Finalize();
return(bytes);
}
public byte[] SerializeMessage(IUdpMessage message)
{
var writer = new DataWriter();
writer.Write(HEADER_VERIFICATION, false);
var cmdName = message.GetType().Name;
writer.Write(cmdName);
writer.Write(_loop.TickIndex);
message.Serialize(writer);
var bytes = writer.Finalize();
return(bytes);
}
public async Task <IUdpMessage> SendMessage(IUdpMessage message, string ip, int port)
{
var sendPacket = packetCreator.CreatePacket(message);
using (UdpClient client = new UdpClient())
{
var remoteEP = new IPEndPoint(IPAddress.Parse(ip), port);
await client.SendAsync(sendPacket.Buffer, sendPacket.Size, remoteEP);
var receiveBytes = await client.ReceiveAsync();
return(packetReader.ReadPacket(new Packet(receiveBytes.Buffer)));
}
}
public async Task <IUdpMessage> SendMessage(IUdpMessage message, string ip, int port)
{
var sendPacket = this.udpPacketService.CreatePacket(message);
using UdpClient client = new UdpClient();
var remoteEP = new IPEndPoint(IPAddress.Parse(ip), port);
await client.SendAsync(sendPacket.Buffer, sendPacket.Size, remoteEP);
Task timeoutTask = Task.Delay(TimeSpan.FromSeconds(10));
var receiveBytesTask = client.ReceiveAsync();
await Task.WhenAny(timeoutTask, receiveBytesTask);
if (timeoutTask.IsCompleted)
{
throw new OttdConnectionException("Udp server did not respond!");
}
return(this.udpPacketService.ReadPacket(new Packet(receiveBytesTask.Result.Buffer)));
}
//ReceiveCallback will be called asynchronously
private void ReceiveCallback(IAsyncResult ar)
{
UdpState state = (UdpState)ar.AsyncState;
UdpClient stateClient = state.client;
IPEndPoint stateEndPoint = state.endPoint;
try
{
IPEndPoint receiveEndPoint = new(IPAddress.Any, ListenerConfig.BroadcastPort);
byte[] receivedBytes = stateClient.EndReceive(ar, ref receiveEndPoint);
try
{
string receivedString = Encoding.UTF8.GetString(receivedBytes);
//Translate the incoming IUdpMessage to a IUdpTransport
IUdpMessage message = JsonSerializer.Deserialize <UdpMessage>(receivedString);
IUdpTransportMessage transportMessage = message.ToUdpTransportMessage(receiveEndPoint.Address, receiveEndPoint.Port);
//Post this message as an event
MessageReceived?.Invoke(transportMessage);
}
catch (Exception ex)
{
logger.LogError(ex.Message);
}
finally
{
//Start receiving again
_ = stateClient.BeginReceive(new AsyncCallback(ReceiveCallback), state);
}
}
catch (ObjectDisposedException)
{
//This is, according to Microsoft, a perfectly normal way of ending a BeginReceive when closing the socket
//https://social.msdn.microsoft.com/Forums/en-US/18a48d01-108c-4eff-b19e-bb59645d42f8/closing-a-socket-connection-created-using-udp-client?forum=vcgeneral
logger.LogInformation($"Closed connection.");
}
}
public void Simulate(uint tickIndex)
{
if (_messages.Count == 0)
{
return;
}
_messagesCopy.Clear();
_messagesCopy.AddRange(_messages);
_messages.Clear();
for (int i = 0; i < _messagesCopy.Count; i++)
{
IUdpMessage message = _messagesCopy[i];
if (message != null && _handlers.TryGetValue(message.GetType(), out List <IMessageHandler> handlers))
{
foreach (var r in handlers)
{
r.Handle(message);
}
}
}
}
public void SendMessage(IUdpMessage message, IPEndPoint remote)
{
var bytes = _serializer.SerializeMessage(message);
_connection.Send(remote, bytes);
}
public void Receive(IUdpMessage message)
{
Receive(message as T);
}
public void SendMessage(IUdpMessage message)
{
var bytes = _serializer.SerializeMessage(message);
_connection.Send(_serverEndpoint, bytes);
}
public void Post(IUdpMessage message)
{
_messages.Push(message);
}
public void Send(IUdpMessage message, IPAddress address, int port) => SendMessage(message, address, port, false);
public IUdpTransportMessage SendWithResponse(IUdpMessage message, IPAddress address, int port) => SendMessage(message, address, port, true);
public void Broadcast(IUdpMessage message, int port) => SendMessage(message, IPAddress.Broadcast, port, false);
public void AddMessage(IUdpMessage message)
{
_messages.Add(message);
}
public IUdpTransportMessage BroadcastWithResponse(IUdpMessage message, int port) => SendMessage(message, IPAddress.Broadcast, port, true);
public void Receive(IUdpMessage message)
{
Receive(message as DebugLogMessage);
}
public void Handle(IUdpMessage message)
{
Handle(message as T);
}
public async Task <PacketUdpServerResponse> AskAboutServerInfo()
{
IUdpMessage response = await udpClient.SendMessage(new PacketUdpClientFindServer(), ServerInfo.ServerIp, ServerInfo.ServerPort);
return(response as PacketUdpServerResponse);
}
public void SendMessage(IUdpMessage message, ConnectedClient client)
{
var bytes = _serializer.SerializeMessage(message);
_connection.Send(client.Remote, bytes);
}
