/// <summary>
/// Begins an operation to accept a connection request from the client
/// </summary>
/// <param name="e">The context object to use when issuing the accept operation on the server's listening socket</param>
private void StartAccept(SocketAsyncEventArgs e)
{
if (e == null)
{
e = new SocketAsyncEventArgs();
e.Completed += (sender, completedE) => AcceptCompleted(completedE);
}
else
{
// socket must be cleared since the context object is being reused
e.AcceptSocket = null;
}
_connectionLimit.WaitOne();
try
{
if (MainSocket.AcceptAsync(e) == false)
{
AcceptCompleted(e);
}
}
catch (ObjectDisposedException)
{
// ignored
}
}
public async void Start()
{
Logger.Warning("The CSF Discord Bot Core is a really unstable early version!");
GatewayGetter gg = new GatewayGetter(token);
try {
Logger.Info("Requesting Gateway data...");
GatewayGetter.GatewayResponse response = gg.GetGateway();
Uri u = new Uri(response.url + "?format=json");
int shard_count = response.shards;
for (int i = 0; i < shard_count; i++)
{
MainSocket socket = new MainSocket(u, token, i, shard_count);
foreach (Processor p in processors)
{
p.SetToken(token);
p.SetClient(this);
socket.AddProcessor(p);
}
shards.Add(socket);
}
foreach (MainSocket ms in shards)
{
await ms.Connect();
}
started = true;
} catch (Exception e) {
Logger.Error($"Server startup failed: {e.Message}");
}
}
public void Dispose()
{
if (MainSocket != null)
{
MainSocket.Close();
}
}
private void Reconnect(object state)
{
lock (_sync)
{
try
{
var now = DateTimeOffset.Now;
if (!IsConnected)
{
if ((now - _lastConnected).TotalSeconds > 5)
{
Start(true);
}
}
else if (_lastPing > _lastPong && (now - _lastPong).TotalSeconds > 20)
{
MainSocket?.Close();
}
else if ((now - _lastPing).TotalSeconds > 5)
{
_lastPing = DateTimeOffset.Now;
MainSocket.C2S_KeepAlive();
}
}
catch { }
finally
{
_reconnectTimer.Change(100, Timeout.Infinite);
}
}
}
public DDD_StatusComponent(MainSocket mainSocketIn)
{
handler = new DDD_StatusComponentHandler(mainSocketIn);
DataContext = handler.status;
InitializeComponent();
TestComponent.Content = handler.testComponent;
}
public DDD_tboxdtComponent(MainSocket mainSocketIn, bool isSoraIn)
{
handler = new DDD_tboxdtHandler(mainSocketIn, isSoraIn);
DataContext = handler.file;
InitializeComponent();
TestComponent.Content = handler.testComponent;
}
public DDD_lboardComponent(MainSocket mainSocketIn)
{
handler = new DDD_lboardHandler(mainSocketIn);
DataContext = handler;
InitializeComponent();
TestComponent.Content = handler.testComponent;
}
public DDD_itemdataComponent(MainSocket mainSocketIn)
{
handler = new DDD_itemdataHandler(mainSocketIn);
DataContext = handler.file;
InitializeComponent();
TestComponent.Content = handler.testComponent;
}
public void Stop()
{
lock (_sync)
{
_reconnectTimer.Change(Timeout.Infinite, Timeout.Infinite);
MainSocket?.Close();
}
}
public DDD_techprmComponent(MainSocket mainSocketIn, bool isPlayerIn)
{
handler = new DDD_techprmHandler(mainSocketIn, isPlayerIn);
DataContext = handler;
InitializeComponent();
TestComponent.Content = handler.testComponent;
}
/// <summary>
/// Disconnects the client from any established connections.
/// </summary>
public void Disconnect()
{
var noDelay = MainSocket.NoDelay;
MainSocket.Dispose();
MainSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
{
NoDelay = noDelay
};
}
private void Connect(string remoteAddress, int remotePort)
{
try
{
MainSocket.BeginConnect(remoteAddress, remotePort, OnConnect, null);
}
catch (Exception ex)
{
FireException(ExceptionType.Connect, ex.Message);
}
}
private void Accept(int localPort)
{
try
{
MainSocket.BeginAccept(OnAccept, localPort);
}
catch (Exception ex)
{
FireException(ExceptionType.Accept, ex.Message);
}
}
public MainTestSocketed(MainSocket mainSocketIn, Enums.ProcessType procType, bool readOn, bool writeOn, bool exportOn)
{
mainSocket = mainSocketIn;
try
{
testComponent = new TestComponent(procType, this, readOn, writeOn, exportOn);
}
catch (Exception e)
{
mainSocket.writeInfoLabel("Couldn't hook to process. Make sure the app is running in admin mode if the game is.");
}
}
// CONSTRUCTORS
public DDD_techprmHandler(MainSocket mainSocketIn, bool isPlayerIn) : base(mainSocketIn, Enums.ProcessType.DDD_EGS)
{
file = new DDD_techprm_File();
isPlayer = isPlayerIn;
if (isPlayer)
{
fileAddress = (long)DDD_Pointers.TECHPRMP_MOD_EGS;
}
else
{
fileAddress = (long)DDD_Pointers.TECHPRM_MOD_EGS;
}
}
private void OnConnect(IAsyncResult ar)
{
try
{
MainSocket.EndConnect(ar);
FireConnect();
Receive();
}
catch (Exception ex)
{
FireException(ExceptionType.Connect, ex.Message);
}
}
protected override void OnClose(TSession session, SocketCloseReason reason)
{
MainSocket.Close();
TSession sessOut;
// If the session is null, the connection timed out while trying to connect.
if (session != null)
{
ConnectedSessions.TryRemove(Session.Id, out sessOut);
}
base.OnClose(session, reason);
}
private void OnAccept(IAsyncResult ar)
{
try
{
int localPort = (int)ar.AsyncState;
Socket acceptedSocket = MainSocket.EndAccept(ar);
NetSocket netSocket = new NetSocket(acceptedSocket, BufferLength);
FireAccept(netSocket);
Accept(localPort);
}
catch (Exception ex)
{
FireException(ExceptionType.Accept, ex.Message);
}
}
/// <summary>
/// Terminates this server and notify all connected clients.
/// </summary>
public void Stop()
{
if (_isStopped)
{
return;
}
TSession[] sessions = new TSession[ConnectedSessions.Values.Count];
ConnectedSessions.Values.CopyTo(sessions, 0);
foreach (var session in sessions)
{
session.Close(SocketCloseReason.ServerClosing);
}
MainSocket.Close();
_isStopped = true;
}
// TODO: Add user list
public static void OnUserConnect(IAsyncResult ar)
{
SausageConnection user;
try
{
user = new SausageConnection(MainSocket.EndAccept(ar));
}
catch (SocketException ex)
{
Close();
return;
}
catch (ObjectDisposedException ex)
{
return;
}
if (!Blacklisted.Any(x => x == user.Ip.Address))
{
UiCtx.Send(x => ConnectedUsers.Add(user));
UiCtx.Send(x => Vm.ConnectedUsers = SortUsersList());
UiCtx.Send(x => Vm.Messages.Add(new ServerMessage($"{user} has connected")));
UiCtx.Send(x => Mw.AddTextToDebugBox($"User connected on {user.Ip}\n"));
// global packet for all the users to know the user has joined
PacketFormat GlobalPacket = new PacketFormat(PacketOption.UserConnected)
{
Guid = user.UserInfo.Guid,
NewName = user.UserInfo.Name
};
// local packet for the user (who joined) to get his GUID
PacketFormat LocalPacket = new PacketFormat(PacketOption.GetGuid)
{
Guid = user.UserInfo.Guid,
UsersList = UsersDictionary.ToArray()
};
UsersDictionary.Add(user.UserInfo);
user.SendAsync(LocalPacket);
Log(GlobalPacket, user);
}
else
{
// doesn't log if the user is blacklisted
user.Disconnect();
}
MainSocket.BeginAccept(OnUserConnect, null);
}
private void HandleNewExternalSocket(Socket socket)
{
Console.WriteLine($"New external socket from {socket.RemoteEndPoint}");
if (MainSocket?.IsConnected ?? false)
{
var channel = CreateNewChannel(socket);
try
{
MainSocket.S2C_StartNewConnection(channel.ChannelId, Mapping.TargetPort, Mapping.InternalPort);
}
catch (Exception ex)
{
socket.Close();
channel.Close(ex);
}
}
}
public static void Close()
{
if (IsOpen)
{
MainSocket.Close();
foreach (SausageConnection u in ConnectedUsers)
{
u.Disconnect();
}
UiCtx.Send(x => Vm.Messages = new ObservableCollection <IMessage>());
UiCtx.Send(x => Vm.Messages.Add(new ServerMessage("Closed all sockets")));
IsOpen = false;
}
else
{
MessageBox.Show("Server is already closed", "Sausage Server");
}
}
private void HandleStartNewConnection(ProtocolSocket socket, int id, ushort targetPort, ushort internalPort)
{
Console.WriteLine($"HandleStartNewConnection #{id} target={targetPort} internal={internalPort}");
var localSocket = TryConnect(BoundInterface.ToString(), targetPort);
var remoteSocket = TryConnect(RelayAddress, internalPort);
var success = localSocket != null && remoteSocket != null;
if (IsConnected)
{
MainSocket.C2S_StartNewConnectionReply(id, internalPort, success);
}
var protoSocket = new ProtocolSocket(remoteSocket);
protoSocket.C2S_StartRelay(id);
var proxy = new ChannelProxy(localSocket);
proxy.ChannelId = id;
proxy.SetProxy(protoSocket);
}
static void Main(string[] args)
{
int Port = 9230;
var server = new MainSocket(Port);
// Intialize the hashes...
ConquerHash = GetFileHash(@"Files\Conquer.exe");
MagicHash = GetFileHash(@"Files\ini\MagicEffect.ini");
Console.WriteLine($"Socket is alive on port {Port}");
Console.Title = $"Protection Server - {Port}";
Console.WriteLine();
new Thread(new ThreadStart(Protection)).Start();
while (true)
{
Console.ReadLine();
}
}
private void HandleNewSocket(Socket socket)
{
if (MainSocket == null || !MainSocket.IsConnected || (DateTimeOffset.Now - _lastPing).TotalSeconds > 15)
{
Console.WriteLine($"Replacing the old socket with one from {socket.RemoteEndPoint}");
if (MainSocket != null)
{
MainSocket.Close();
}
_lastPing = DateTimeOffset.Now;
MainSocket = new ProtocolSocket(socket);
MainSocket.C2S_OnStartNewConnectionReply = HandleConnectionReply;
MainSocket.C2S_OnKeepAlive = HandleKeepAlive;
MainSocket.Initialize();
}
else
{
socket.Close();
}
}
private void Accept(IAsyncResult result)
{
HTTPSession WebSession;
try
{
Socket AcceptedSocket = MainSocket.EndAccept(result);
lock (SessionTable)
{
WebSession = new HTTPSession(LocalIPEndPoint, AcceptedSocket);
WebSession.OnClosed += CloseSink;
WebSession.OnHeader += HandleHeader;
WebSession.OnReceive += HandleRequest;
SessionTable[WebSession] = WebSession;
}
SessionTimer.Add(WebSession, 3);
OnSessionEvent.Fire(this, WebSession);
WebSession.StartReading();
}
catch (Exception err)
{
if (err.GetType() != typeof(ObjectDisposedException))
{
// Error
EventLogger.Log(err);
}
}
try
{
MainSocket.BeginAccept(Accept, null);
}
catch (Exception ex)
{
EventLogger.Log(ex);
// Socket was closed
}
}
private void Accept(IAsyncResult result)
{
HTTPSession WebSession = null;
try
{
Socket AcceptedSocket = MainSocket.EndAccept(result);
lock (SessionTable)
{
WebSession = new HTTPSession(this.LocalIPEndPoint, AcceptedSocket);
WebSession.OnClosed += new HTTPSession.SessionHandler(CloseSink);
WebSession.OnHeader += new HTTPSession.ReceiveHeaderHandler(HandleHeader);
WebSession.OnReceive += new HTTPSession.ReceiveHandler(HandleRequest);
SessionTable[WebSession] = WebSession;
}
SessionTimer.Add(WebSession, 3);
OnSessionEvent.Fire(this, WebSession);
WebSession.StartReading();
}
catch (Exception err)
{
if (err.GetType() != typeof(System.ObjectDisposedException))
{
// Error
OpenSource.Utilities.EventLogger.Log(err);
}
}
try
{
MainSocket.BeginAccept(new AsyncCallback(Accept), null);
}
catch (Exception ex)
{
OpenSource.Utilities.EventLogger.Log(ex);
// Socket was closed
}
}
// CONSTRUCTORS
public DDD_tboxdtHandler(MainSocket mainSocketIn, bool isSoraIn) : base(mainSocketIn, Enums.ProcessType.DDD_EGS)
{
file = new DDD_tboxdt_File();
file.isSora = isSoraIn;
}
/// <summary>
/// Binds the socket to the specified address
/// </summary>
public void BindSocket(string ip, int port)
{
SetAddress(ip, port);
MainSocket.Bind(_socketAddress);
}
/// <summary>
/// Begins listening for and accepting socket connections.
/// </summary>
/// <param name="backLog">Maximum amount of pending connections</param>
public void Listen(int backLog = 25, int maximumConnections = 60)
{
_connections = new Connection[maximumConnections];
var listenerThread = new Thread(() =>
{
int index = -1;
if (_socketAddress == null)
{
throw new Exception("You must specifiy the socket address before calling the listen method!");
}
if (!MainSocket.IsBound)
{
throw new Exception("You must bind the socket before calling the listen method!");
}
MainSocket.Listen(backLog);
Console.WriteLine("[NettyServer] Server listening on address: " + MainSocket.LocalEndPoint);
while (true)
{
var incomingSocket = MainSocket.Accept();
for (int i = 0; i < maximumConnections; i++)
{
if (_connections[i] == null)
{
_connections[i] = new Connection(incomingSocket, this)
{
Socket = { NoDelay = MainSocket.NoDelay }
};
index = i;
break;
}
}
Console.WriteLine("[NettyServer] Received a connection from: " + incomingSocket.RemoteEndPoint);
if (Handle_NewConnection != null)
{
Handle_NewConnection.Invoke(index);
}
try
{
Thread recThread = new Thread(x => BeginReceiving(incomingSocket, index));
recThread.Name = incomingSocket.RemoteEndPoint + ": incoming data thread.";
recThread.Start();
}
catch (ObjectDisposedException)
{
}
}
})
{
Name = "NettyServer Incoming Connection Thread"
};
listenerThread.Start();
}