public SSPClient ProcessClient(SSPServer Server, Socket TcpServer, IAsyncResult result)
{
try
{
Socket AcceptSocket = TcpServer.EndAccept(result); //<- can throw a error
SSPClient client = Server.GetNewClient();
client.Handle = AcceptSocket;
if (AcceptSocket.AddressFamily == AddressFamily.InterNetworkV6)
{
client.RemoteIp = ((IPEndPoint)AcceptSocket.RemoteEndPoint).Address.ToString();
}
else
{
client.RemoteIp = AcceptSocket.RemoteEndPoint.ToString().Split(':')[0];
}
client.Server = Server;
client.Connection = new Network.Connection(client);
client.ClientId = Server.randomDecimal.NextDecimal();
client.serverHS = new ServerMaze(Server.serverProperties.Handshake_Maze_Size, Server.serverProperties.Handshake_MazeCount, Server.serverProperties.Handshake_StepSize);
client.serverHS.onFindKeyInDatabase += Server.serverHS_onFindKeyInDatabase;
SysLogger.Log("Accepted peer " + client.RemoteIp, SysLogType.Debug);
lock (Server.Clients)
{
while (Server.Clients.ContainsKey(client.ClientId))
{
client.ClientId = Server.randomDecimal.NextDecimal();
}
Server.Clients.Add(client.ClientId, client);
}
try
{
client.onBeforeConnect();
}
catch (Exception ex)
{
SysLogger.Log(ex.Message, SysLogType.Error);
client.onException(ex, ErrorType.UserLand);
}
client.Connection.StartReceiver();
return(client);
}
catch (Exception ex)
{
SysLogger.Log(ex.Message, SysLogType.Error);
return(null);
}
}
public override void ProcessPayload(SSPClient client, OperationalSocket OpSocket)
{
ReturnResult result = new ReturnResult(null, false);
LiteCodeClient Client = OpSocket as LiteCodeClient;
try
{
PayloadReader pr = new PayloadReader(Data);
SharedClass sClass = null;
if (Client.InitializedClasses.TryGetValue(SharedClassId, out sClass))
{
SharedMethod sharedMethod = sClass.GetMethod(MethodId);
if (sharedMethod != null)
{
List <object> args = new List <object>();
List <Type> types = new List <Type>();
SortedList <int, SharedDelegate> SharedDelegates = new SortedList <int, SharedDelegate>();
SmartSerializer serializer = new SmartSerializer();
lock (sharedMethod.Delegates)
{
SharedDelegate sharedDel = null;
if (sharedMethod.Delegates.TryGetValue(DelegateId, out sharedDel))
{
for (int i = 0; i < sharedDel.sharedMethod.ArgumentTypes.Length; i++)
{
args.Add(serializer.Deserialize(pr.ReadBytes(pr.ReadInteger())));
}
}
else
{
for (int i = 0; i < sharedMethod.ArgumentTypes.Length; i++)
{
args.Add(serializer.Deserialize(pr.ReadBytes(pr.ReadInteger())));
}
}
}
if (!isDelegate) //atm no support yet for delegate inside another delegate
{
for (int i = 0; i < sharedMethod.DelegateIndex.Count; i++)
{
if (pr.ReadByte() == 1)
{
SharedDelegate del = pr.ReadObject <SharedDelegate>();
del.sharedMethod.sharedClass = sClass;
args[sharedMethod.DelegateIndex.Keys[i]] = DynamicDelegateCreator.CreateDelegate(del);
SharedDelegates.Add(del.sharedMethod.DelegateId, del);
}
}
}
if (isDelegate)
{
result.ReturnValue = sharedMethod.Delegates[DelegateId].Delegate.DynamicInvoke(args.ToArray());
}
else
{
if (sharedMethod.CallCache == null)
{
MethodInfo methodInf = sClass.InitializedClass.GetType().GetMethod(sharedMethod.Name, sharedMethod.ArgumentTypes);
sharedMethod.CallCache = methodInf.Bind();
}
result.ReturnValue = sharedMethod.CallCache(sClass.InitializedClass, args.ToArray());
/*MethodInfo methodInf = sClass.InitializedClass.GetType().GetMethod(sharedMethod.Name, sharedMethod.ArgumentTypes);
* result.ReturnValue = methodInf.Invoke(sClass.InitializedClass, args.ToArray());*/
}
}
}
}
catch (Exception ex)
{
result.exceptionMessage = ex.InnerException != null ? ex.InnerException.Message : ex.Message;
result.ExceptionOccured = true;
client.onException(ex.InnerException != null ? ex.InnerException : ex, ErrorType.UserLand);
}
if (RequireResultBack)
{
Client.Send(new MsgExecuteMethodResponse(RequestId, result));
}
}
public override void ProcessPayload(SSPClient client, OperationalSocket OpSocket)
{
SSPClient _client = client as SSPClient;
if (_client != null)
{
byte[] responseData = new byte[0];
MazeErrorCode errorCode = MazeErrorCode.Error;
Mazing mazeHandshake = _client.IsServerSided ? _client.serverHS : _client.clientHS;
if (mazeHandshake == null)
{
//error could occur on a unexpected disconnect
client.Connection.HandShakeCompleted = false;
client.Connection.HandshakeSync.Pulse();
return;
}
errorCode = mazeHandshake.onReceiveData(Data, ref responseData);
if (errorCode != MazeErrorCode.Finished && errorCode != MazeErrorCode.Success && client.TimingConfiguration.Enable_Timing)
{
//something went wrong, annoy the attacker
Thread.Sleep(client.TimingConfiguration.Authentication_WrongPassword);
}
if (responseData.Length > 0)
{
client.Connection.SendMessage(new MsgHandshake(responseData), new SystemHeader());
}
if(client == null || client.Connection == null || client.Connection.HandshakeSync == null)
{
//error could occur on a unexpected disconnect
return;
}
client.Connection.HandshakeSync.Value = errorCode;
if (errorCode != MazeErrorCode.Finished && errorCode != MazeErrorCode.Success)
{
client.Connection.HandshakeSync.Pulse();
}
else if (errorCode == MazeErrorCode.Finished)
{
//let's tell it's completed and apply the new key
client.Connection.ApplyNewKey(mazeHandshake, mazeHandshake.FinalKey, mazeHandshake.FinalSalt);
if (_client.IsServerSided)
{
if (mazeHandshake as ServerMaze != null)
{
client.Username = (mazeHandshake as ServerMaze).Username;
}
client.Connection.HandShakeCompleted = true;
/*try
{
client.onBeforeConnect();
}
catch (Exception ex)
{
SysLogger.Log(ex.Message, SysLogType.Error);
client.onException(ex, ErrorType.UserLand);
return; //don't send that we're ready since we're clearly not at this point
}*/
client.Connection.SendMessage(new MsgInitOk(), new SystemHeader());
try
{
client.onConnect();
}
catch (Exception ex)
{
SysLogger.Log(ex.Message, SysLogType.Error);
client.onException(ex, ErrorType.UserLand);
return; //don't send that we're ready since we're clearly not at this point
}
}
else
{
client.Connection.HandShakeCompleted = true;
client.Connection.HandshakeSync.Pulse();
}
}
}
}
public override void ProcessPayload(SSPClient client, OperationalSocket OpSocket)
{
SSPClient _client = client as SSPClient;
if (_client != null)
{
byte[] responseData = new byte[0];
MazeErrorCode errorCode = MazeErrorCode.Error;
Mazing mazeHandshake = _client.IsServerSided ? _client.serverHS : _client.clientHS;
if (mazeHandshake == null)
{
//error could occur on a unexpected disconnect
client.Connection.HandShakeCompleted = false;
client.Connection.HandshakeSync.Pulse();
return;
}
errorCode = mazeHandshake.onReceiveData(Data, ref responseData);
if (errorCode != MazeErrorCode.Finished && errorCode != MazeErrorCode.Success && client.TimingConfiguration.Enable_Timing)
{
//something went wrong, annoy the attacker
Thread.Sleep(client.TimingConfiguration.Authentication_WrongPassword);
}
if (responseData.Length > 0)
{
client.Connection.SendMessage(new MsgHandshake(responseData), new SystemHeader());
}
if (client == null || client.Connection == null || client.Connection.HandshakeSync == null)
{
//error could occur on a unexpected disconnect
return;
}
client.Connection.HandshakeSync.Value = errorCode;
if (errorCode != MazeErrorCode.Finished && errorCode != MazeErrorCode.Success)
{
client.Connection.HandshakeSync.Pulse();
}
else if (errorCode == MazeErrorCode.Finished)
{
//let's tell it's completed and apply the new key
client.Connection.ApplyNewKey(mazeHandshake, mazeHandshake.FinalKey, mazeHandshake.FinalSalt);
if (_client.IsServerSided)
{
if (mazeHandshake as ServerMaze != null)
{
client.Username = (mazeHandshake as ServerMaze).Username;
}
client.Connection.HandShakeCompleted = true;
/*try
* {
* client.onBeforeConnect();
* }
* catch (Exception ex)
* {
* SysLogger.Log(ex.Message, SysLogType.Error);
* client.onException(ex, ErrorType.UserLand);
* return; //don't send that we're ready since we're clearly not at this point
* }*/
client.Connection.SendMessage(new MsgInitOk(), new SystemHeader());
try
{
client.onConnect();
}
catch (Exception ex)
{
SysLogger.Log(ex.Message, SysLogType.Error);
client.onException(ex, ErrorType.UserLand);
return; //don't send that we're ready since we're clearly not at this point
}
}
else
{
client.Connection.HandShakeCompleted = true;
client.Connection.HandshakeSync.Pulse();
}
}
}
}