public void Send(BufferPool.Buffer datagram)
{
foreach (IPEndPoint broadcast in broadcastAddresses)
{
Send(broadcast, datagram);
}
}
public ReceiveState(IPEndPoint ip)
{
this.ip = ip;
data = null;
offset = 0;
}
public void Send(IPEndPoint endpoint, BufferPool.Buffer datagram)
{
if (datagram.Size > 0 && datagram.Size <= datagram.Data.Length)
{
udp.SendAsync(datagram.Data, (int)datagram.Size, endpoint);
}
}
public void Send(Guid remote, ushort channel, BufferPool.Buffer data, bool dispose_buffer = true)
{
if (state == State.RUNNING)
{
Connection.Base[] client_channels;
Connection.Base client_channel;
lock (openedChannels)
{
if (!openedChannels.TryGetValue(remote, out client_channels))
{
throw new ArgumentException(string.Format("No connection with remote '{0}'. Nothing sent.", remote), "remote");
}
if (channel >= client_channels.Length || client_channels[channel] == null)
{
throw new ArgumentException(string.Format("Invalid channel. No channel with index '{0}'", channel), "channel");
}
client_channel = client_channels[channel];
}
client_channel.SendAsync(data, dispose_buffer);
}
else
{
Debug.LogWarningFormat("Can not send data when in state {0}. Nothing sent.", state);
}
}
protected override void SendAsync(Threads.Result result, BufferPool.Buffer data, bool dispose_buffer = true)
{
try
{
if (Connected())
{
Converter32 c = new Converter32(data.Size);
writeBuffer.Data[0] = c.Byte1;
writeBuffer.Data[1] = c.Byte2;
writeBuffer.Data[2] = c.Byte3;
writeBuffer.Data[3] = c.Byte4;
BeginSend(writeBuffer.Data, writeBuffer.Data.Length, FinalizeSendLength, new SendState(result, data, dispose_buffer));
}
else
{
throw new ArgumentNullException("client", "The connection is not opened.");
}
}
catch (Exception e)
{
result.Complete(e);
}
}
public Socket(Negotiation.Base parent, Message.Negotiation.Parameters parameters, UnityAction <Base> disconnection_handler, System.Net.Sockets.Socket socket) : base(parent, parameters, disconnection_handler)
{
this.socket = socket;
readBuffer = new BufferPool.Buffer(null, new byte[sizeof(int)], false);
writeBuffer = new BufferPool.Buffer(null, new byte[sizeof(int)], false);
}
protected void Worker()
{
WaitHandle[] wait = new WaitHandle[] { stopEvent, addEvent };
BufferPool.Buffer heartbeat_data = new BufferPool.Buffer(null, new byte[0], false);
int event_idx;
while ((event_idx = WaitHandle.WaitAny(wait, parameters.heartbeat)) != 0)
{
if (event_idx == WaitHandle.WaitTimeout)
{
// Handle heartbeat
if (sendResult == null || sendResult.Done)
{
sendResult = CreateResult();
SendAsync(sendResult, heartbeat_data, false);
}
}
else
{
Threads.Task task = null;
lock (addEvent)
{
if (sendResult == null || sendResult.Done)
{
sendResult = null;
lock (sendQueue)
{
if (sendQueue.Count > 0)
{
task = sendQueue.Dequeue();
}
else
{
// Nothing to do anymore, go to sleep
addEvent.Reset();
}
}
}
else
{
// Not done yet, go to sleep
addEvent.Reset();
}
}
if (task != null)
{
sendResult = (Threads.Result)task.result;
task.callback();
}
}
}
}
public Tcp(Negotiation.Base parent, Message.Negotiation.Parameters parameters, UnityAction <Base> disconnection_handler, TcpClient client) : base(parent, parameters, disconnection_handler, client.Client)
{
this.client = client;
stream = null;
headerBuffer = new BufferPool.Buffer(null, new byte[headerSize], false);
}
public void Set(BufferPool.Buffer data, uint size)
{
this.data = data;
this.data.Size = size;
offset = 0;
}
public void Receive(IPAddress remote, Guid id, ushort channel, BufferPool.Buffer data)
{
if (onReceive.GetPersistentEventCount() > 0)
{
lock (deserializationTasks)
{
DeserializationContext context = new DeserializationContext(r => onReceive.Invoke(remote, id, channel, r));
context.task = serializer.Deserialize(new Binary.Buffer(data, serializer), context.DeserializationCallback, null);
deserializationTasks.Enqueue(context);
}
}
}
protected void FinalizeReceiveData(IAsyncResult async_result)
{
FinalizeReceive(async_result, state =>
{
BufferPool.Buffer data = state.data; // Otherwise the call to state.data in unity thread will be evaluated to null, because of the weird catching of parameters of lambdas
Threads.APC.MonoBehaviourCall.Instance.Call(() => events.onReceive.Invoke(state.ip.Address, parameters.guid, parameters.channel, data));
state.Set(readBuffer, (uint)readBuffer.Data.Length);
// Wait for next message
BeginReceive(state.data.Data, state.offset, state.MissingDataLength, FinalizeReceiveLength, state);
});
}
public void SendAsync(BufferPool.Buffer data, bool dispose_buffer = true)
{
if (!disposed)
{
lock (sendQueue)
{
Threads.Result result = CreateResult();
sendQueue.Enqueue(new Threads.Task(() => SendAsync(result, data, dispose_buffer), result));
}
lock (addEvent)
{
addEvent.Set();
}
}
}
protected void SendBeacon(bool exist)
{
if (advertise != null)
{
foreach (Service service in advertise)
{
if (service.server != null)
{
try
{
IServiceInfo info = service.info.ServiceInfo;
if (info != null)
{
info.Active = exist && service.server.CurrentState == Negotiation.Base.State.RUNNING;
BufferPool.Buffer data = serializer.Serialize(new Datagram(exist, service.server.port, info));
if (data != null && data.Size > 0)
{
broadcast.Send(data);
if (manualPeers != null)
{
foreach (Peer peer in manualPeers)
{
if (IPAddress.TryParse(peer.ip, out IPAddress ip))
{
broadcast.Send(new IPEndPoint(ip, peer.port), data);
}
}
}
}
}
}
catch (Binary.SerializationException e) {
Debug.LogErrorFormat("{1}: {2}\n{3}", e.GetType(), e.Message, e.StackTrace);
}
}
}
}
}
protected bool ReceiveData(Stream stream, BufferPool.Buffer buffer, uint size)
{
int received = 0;
try
{
while (received < size)
{
received += stream.Read(buffer.Data, received, (int)(size - received));
}
}
catch (Exception e)
{
HandleException(e);
return(false);
}
return(true);
}
public void SendOthers(Guid remote, ushort channel, BufferPool.Buffer data, bool dispose_buffer = true)
{
if (state == State.RUNNING)
{
lock (openedChannels)
{
if (dispose_buffer)
{
data.SetReferencesCount((uint)openedChannels.Count);
}
foreach (KeyValuePair <Guid, Connection.Base[]> pair in openedChannels)
{
if (remote == Guid.Empty || pair.Key != remote)
{
if (channel >= pair.Value.Length || pair.Value[channel] == null)
{
throw new ArgumentException(string.Format("Invalid channel. No channel with index '{0}'", channel), "channel");
}
pair.Value[channel].SendAsync(data, dispose_buffer);
}
else
{
if (dispose_buffer)
{
data.DecrementReferencesCount();
}
}
}
}
}
else
{
Debug.LogWarningFormat("Can not send data when in state {0}. Nothing sent.", state);
}
}
public void SendAll(ushort channel, BufferPool.Buffer data, bool dispose_buffer = true)
{
SendOthers(Guid.Empty, channel, data, dispose_buffer);
}
protected abstract void SendAsync(Threads.Result result, BufferPool.Buffer data, bool dispose_buffer = true);
protected abstract void OnMonitorReceive(IPAddress address, Guid guid, ushort channel, BufferPool.Buffer data);
protected override void OnMonitorReceive(IPAddress address, Guid guid, ushort channel, BufferPool.Buffer data)
{
Message.Base msg = ReceiveMonitorCommand(data);
if (msg.IsType <Message.Negotiation.Channel.UDP>())
{
Message.Negotiation.Channel.UDP response = (Message.Negotiation.Channel.UDP)msg;
ServerChannel channel_parameters = channels[response.channel];
Message.Negotiation.Parameters param = new Message.Negotiation.Parameters
{
guid = response.guid,
channel = response.channel,
type = channel_parameters.type,
heartbeat = channel_parameters.parameters.Heartbeat,
autoReconnect = !channel_parameters.parameters.disableAutoReconnect
};
Connection.Tcp monitor;
if (monitors.TryGetValue(param.guid, out monitor))
{
UdpConnectionParams udp_param = SendUdpParams(monitor, param);
ConnectUdp(udp_param, response);
}
else
{
Debug.LogErrorFormat("No monitor channel with guid '{0}' to send UDP negotiation for channel {1}", param.guid, param.channel);
}
}
}
public SendState(Threads.Result result, BufferPool.Buffer data, bool dispose_buffer)
{
this.result = result;
this.data = data;
this.dispose_buffer = dispose_buffer;
}
protected override void OnMonitorReceive(IPAddress address, Guid guid, ushort channel, BufferPool.Buffer data)
{
Message.Base msg = ReceiveMonitorCommand(data);
if (msg.IsType <Message.Negotiation.Channel.UDP>())
{
Message.Negotiation.Channel.UDP response = (Message.Negotiation.Channel.UDP)msg;
UdpConnectionParams udp_params = null;
lock (pendingUdpConnection)
{
foreach (UdpConnectionParams pending_udp_params in pendingUdpConnection)
{
if (pending_udp_params.param.guid == response.guid && pending_udp_params.param.channel == response.channel)
{
udp_params = pending_udp_params;
break;
}
}
if (udp_params != null)
{
pendingUdpConnection.Remove(udp_params);
}
}
if (udp_params != null)
{
ConnectUdp(udp_params, (Message.Negotiation.Channel.UDP)msg);
}
else
{
Debug.LogError("Reiceved UDP connection parameters for unrequested connection.");
}
}
}
