protected override void Because()
{
serverMessageReceived = new ServerMessageReceived {
Message = "not private message"
};
sut.Handle(serverMessageReceived);
}
protected override void Because()
{
serverMessageReceived = new ServerMessageReceived {
Message = "PRIVMSG hello hello"
};
sut.Handle(serverMessageReceived);
}
public static bool Connect(Dictionary <string, object> args)
{
string sysname = args["sysname"].ToString();
string username = args["username"].ToString();
string password = args["password"].ToString();
bool connectionFinished = false;
new Thread(() =>
{
Thread.Sleep(10000);
if (connectionFinished == false)
{
Applications.Terminal.IsInRemoteSystem = false;
Applications.Terminal.RemoteSystemName = "";
Applications.Terminal.RemoteUser = "";
Applications.Terminal.RemotePass = "";
TerminalBackend.PrefixEnabled = true;
Console.WriteLine("[rts] Connection failed, target system did not respond.");
TerminalBackend.PrintPrompt();
}
}).Start();
ServerMessageReceived smr = null;
smr = (msg) =>
{
if (msg.Name == "msgtosys")
{
var m = JsonConvert.DeserializeObject <ServerMessage>(msg.Contents);
if (m.GUID.Split('|')[2] != ServerManager.thisGuid.ToString())
{
connectionFinished = true;
ServerManager.MessageReceived -= smr;
}
}
};
ServerManager.MessageReceived += smr;
ServerManager.SendMessageToIngameServer(sysname, 21, "cmd", JsonConvert.SerializeObject(new RTSMessage
{
SenderSystemName = SaveSystem.CurrentSave.SystemName,
Username = username,
Password = password,
Namespace = "trm",
Command = "clear"
}));
Applications.Terminal.IsInRemoteSystem = true;
Applications.Terminal.RemoteSystemName = sysname;
Applications.Terminal.RemoteUser = username;
Applications.Terminal.RemotePass = password;
TerminalBackend.PrefixEnabled = false;
return(true);
}
private void FSD_TextMessageReceived(object sender, DataReceivedEventArgs <PDUTextMessage> e)
{
if (e.PDU.From.ToUpper() == "SERVER")
{
ServerMessageReceived?.Invoke(this, new NetworkDataReceivedEventArgs(e.PDU.From.ToUpper(), e.PDU.Message));
}
else
{
PrivateMessageReceived?.Invoke(this, new NetworkDataReceivedEventArgs(e.PDU.From, e.PDU.Message));
}
}
//private async Task DispatchEvent(string message)
//{
// if (MessageReceived != null)
// {
// await dispatcher.RunAsync(CoreDispatcherPriority.Normal,
// new DispatchedHandler(() =>
// {
// MessageReceived?.Invoke(this, message);
// }));
// }
//}
private async Task DispatchServerEvent(string message)
{
if (ServerMessageReceived != null)
{
await dispatcher.RunAsync(CoreDispatcherPriority.Normal,
new DispatchedHandler(() =>
{
ServerMessageReceived?.Invoke(this, message);
}));
}
}
/// <summary>
/// Static constructor for <see cref="TerminalBackend"/>.
/// </summary>
static TerminalBackend()
{
ServerMessageReceived onMessageReceived = (msg) =>
{
if (msg.Name == "trm_invokecommand")
{
string text3 = "";
string text4 = msg.Contents;
if (TerminalBackend.PrefixEnabled)
{
text3 = text4.Remove(0, $"{SaveSystem.CurrentUser.Username}@{SaveSystem.CurrentSave.SystemName}:~$ ".Length);
}
IsForwardingConsoleWrites = true;
if (TerminalBackend.InStory == false)
{
TerminalBackend.InvokeCommand(text3, true);
}
if (TerminalBackend.PrefixEnabled)
{
Console.Write($"{SaveSystem.CurrentUser.Username}@{SaveSystem.CurrentSave.SystemName}:~$ ");
}
IsForwardingConsoleWrites = false;
}
else if (msg.Name == "pleasewrite")
{
Console.Write(msg.Contents);
}
else if (msg.Name == "handshake_from")
{
var a = JsonConvert.DeserializeObject <Dictionary <string, object> >(msg.Contents);
string uName = a["username"] as string;
string pass = a["password"] as string;
string sys = a["sysname"] as string;
string guid = msg.GUID;
if (SaveSystem.CurrentUser.Username == uName && SaveSystem.CurrentSave.Password == pass && CurrentSave.SystemName == sys)
{
ForwardGUID = guid;
ServerManager.SendMessage("trm_handshake_accept", $@"{{
guid: ""{ServerManager.thisGuid}"",
target: ""{guid}""
}}");
IsForwardingConsoleWrites = true;
InvokeCommand("sos.status");
Console.Write($"{SaveSystem.CurrentUser.Username}@{SaveSystem.CurrentSave.SystemName}:~$ ");
IsForwardingConsoleWrites = false;
}
}
};
ServerManager.MessageReceived += onMessageReceived;
}
private void ServerForm_Load(object sender, EventArgs e)
{
this.Enabled = false;
StartStopServer dele = this.ActionStartStop;
ServerMessageReceived messageReceived = this.ServerCommandReceived;
ServerMessageResponse messageResponse = this.ServerCommandResponse;
AddClientsToServer addClient = this.AddClientToServer;
RemoveClientsToServer removeClient = this.RemoveClientToServer;
SetServerIPAddress serverIP = this.DisplayServerIP;
_server = new Server(this, dele, messageReceived, messageResponse, addClient, removeClient, serverIP);
this.Enabled = true;
}
/// <summary>
/// Handles incoming messages from remote sessions.
/// </summary>
/// <param name="sender">Remote session.</param>
/// <param name="e">Formal junk.</param>
private void Remote_MessageReceived(object sender, EventArgs e)
{
var remote = sender as ActiveSession <T>;
var session = remote.Owner.Origin;
if (remote.Message == null || ((object)remote.Message is X690.Message m && m.IsEndSession))
{
session.Close(); return;
}
ServerMessageReceived?.Invoke(session, new MessageEventArgs <T>(remote, remote.Message));
if (session.IsActive)
{
session.Send(remote.Message);
}
}
// Constructor
public Server(ServerForm form, StartStopServer del, ServerMessageReceived action,
ServerMessageResponse actionResponse, AddClientsToServer addClient,
RemoveClientsToServer removeClient, SetServerIPAddress serverIPDelegate)
{
// Create thread
_serverThread = new Thread(new ThreadStart(ServerMainThreadFunction));
_serverThread.Name = "Server Main Thread";
_serverThread.Start();
// Create thread for UDP connection
_threadSendToClient = new Thread(new ThreadStart(ThreadReceiveResponse));
_threadSendToClient.Name = "Server Thread Listener";
_threadSendToClient.Start();
_parentForm = form;
_endActionDelegate = del;
_messageReceivedAction = action;
_messageResponseAction = actionResponse;
_addClientDelegate = addClient;
_removeClientDelegate = removeClient;
_displayServerIP = serverIPDelegate;
// Get directory of job
_directoryWork = Directory.GetCurrentDirectory();
// Get local IP address
_serverIPAddress = GetPublicIPAddress();
_parentForm.Invoke(_displayServerIP, (object)_serverIPAddress);
// How enable port forwarding
NATUPNPLib.UPnPNATClass upnpnat = new NATUPNPLib.UPnPNATClass();
_mappingsPort = upnpnat.StaticPortMappingCollection;
GetLocalIPAddress();
try
{
_mappingsPort.Add(_numberOfPortToListen, "TCP", _numberOfPortToListen, GetLocalIPAddress(), true, "CNC TCP Server");
}
catch (Exception excp)
{
MessageBox.Show(excp.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
// Send action
_parentForm.Invoke(this._endActionDelegate, (object)false);
return;
}
}
/// <summary>
/// Event handler for messages arriving at the server from a client.
/// </summary>
/// <param name="sender">The client that sent.</param>
/// <param name="args">The event args.</param>
/// <param name="serverID">The ID of the server that received this message.</param>
private void ServerMessageReceivedFromClient(object sender, Server.MessageReceivedEventArgs args, ushort serverID)
{
// Record message
using (Message message = args.GetMessage())
{
string str;
using (DarkRiftReader reader = message.GetReader())
{
if (reader.Length > 0)
{
str = reader.ReadString();
}
else
{
str = null;
}
}
messageAssertions.AddMessageOnServer(new ReceivedMessage(str, args.Client.ID, serverID, message.Tag, args.SendMode));
}
// Call to other event handlers
ServerMessageReceived.Invoke(sender, args);
}
private async Task StartReceive(CancellationToken token)
{
while (!token.IsCancellationRequested)
{
if (!_networkStream.DataAvailable || !_networkStream.CanRead)
{
await Task.Delay(UpdateFrequency, token);
continue;
}
byte[] data;
try
{
data = await ReadAvailableData(token);
}
catch
{
IsStarted = false;
OnFaulted();
return;
}
if (data == null)
{
break;
}
ServerMessageReceived?.Invoke(this, new MidgeMessageReceivedEventArgs(Encoding.GetString(data)));
}
Tcp?.Close();
IsStarted = false;
OnStopped();
}
private void ListeningProc()
{
while (true)
{
Message message = _stream.ReadMessage();
switch (message)
{
case ServerMessage serverMessage:
if (serverMessage is WelcomeMessage welcomeMessage)
{
Name = welcomeMessage.Name;
}
ServerMessageReceived?.Invoke(this, serverMessage);
break;
case RelayMessage relayMessage:
MessageReceived?.Invoke(this, relayMessage);
break;
// TODO: support other messages
}
}
}
/// <summary>
/// Finish bootstrapping the engine.
/// </summary>
private static void FinishBootstrap()
{
ServerMessageReceived savehandshake = null;
savehandshake = (msg) =>
{
if (msg.Name == "mud_savefile")
{
ServerManager.MessageReceived -= savehandshake;
try
{
CurrentSave = JsonConvert.DeserializeObject <Save>(msg.Contents);
}
catch
{
Console.WriteLine("{ENGINE_CANNOTLOADSAVE}");
oobe.PromptForLogin();
}
}
else if (msg.Name == "mud_login_denied")
{
ServerManager.MessageReceived -= savehandshake;
oobe.PromptForLogin();
}
};
ServerManager.MessageReceived += savehandshake;
ReadSave();
while (CurrentSave == null)
{
Thread.Sleep(10);
}
Shiftorium.Init();
while (CurrentSave.StoryPosition < 1)
{
Thread.Sleep(10);
}
Thread.Sleep(75);
Thread.Sleep(50);
Console.WriteLine("{MISC_ACCEPTINGLOGINS}");
Sysname:
bool waitingForNewSysName = false;
bool gobacktosysname = false;
if (string.IsNullOrWhiteSpace(CurrentSave.SystemName))
{
Infobox.PromptText("{TITLE_ENTERSYSNAME}", "{PROMPT_ENTERSYSNAME}", (name) =>
{
if (string.IsNullOrWhiteSpace(name))
{
Infobox.Show("{TITLE_INVALIDNAME}", "{PROMPT_INVALIDNAME}.", () =>
{
gobacktosysname = true;
waitingForNewSysName = false;
});
}
else if (name.Length < 5)
{
Infobox.Show("{TITLE_VALUESMALL}", "{PROMPT_SMALLSYSNAME}", () =>
{
gobacktosysname = true;
waitingForNewSysName = false;
});
}
else
{
CurrentSave.SystemName = name;
SaveSystem.SaveGame();
gobacktosysname = false;
waitingForNewSysName = false;
}
});
}
while (waitingForNewSysName)
{
Thread.Sleep(10);
}
if (gobacktosysname)
{
goto Sysname;
}
if (CurrentSave.Users == null)
{
CurrentSave.Users = new List <ClientSave>();
}
Console.WriteLine($@"
`-:/++++::.`
.+ydNMMMMMNNMMMMMNhs/.
/yNMMmy+:-` `````.-/ohNMMms-
`oNMMh/.`:oydmNMMMMNmhs+- .+dMMm+` {{GEN_WELCOME}}
`oMMmo``+dMMMMMMMMMMMMMMMMMNh/`.sNMN+
:NMN+ -yMMMMMMMNdhyssyyhdmNMMMMNs``sMMd. {{GEN_SYSTEMSTATUS}}
oMMd.`sMMMMMMd+. `/MMMMN+ -mMN: ----------------------
oMMh .mMMMMMM/ `-::::-.` :MMMMMMh`.mMM:
:MMd .NMMMMMMs .dMMMMMMMMMNddMMMMMMMd`.NMN. {{GEN_CODEPOINTS}}: {SaveSystem.CurrentSave.Codepoints}
mMM. dMMMMMMMo -mMMMMMMMMMMMMMMMMMMMMs /MMy
:MMh :MMMMMMMMm` .+shmMMMMMMMMMMMMMMMN` NMN`
oMM+ sMMMMMMMMMN+` `-/smMMMMMMMMMMM: hMM:
sMM+ sMMMMMMMMMMMMds/-` .sMMMMMMMMM/ yMM/
+MMs +MMMMMMMMMMMMMMMMMmhs:` +MMMMMMMM- dMM- {{GEN_SYSTEMNAME}}: {CurrentSave.SystemName.ToUpper()}
.MMm `NMMMMMMMMMMMMMMMMMMMMMo `NMMMMMMd .MMN {{GEN_USERS}}: {Users.Count()}.
hMM+ +MMMMMMmsdNMMMMMMMMMMN/ -MMMMMMN- yMM+
`NMN- oMMMMMd `-/+osso+- .mMMMMMN: +MMd
-NMN: /NMMMm` :yMMMMMMm- oMMd`
-mMMs``sMMMMNdhso++///+oydNMMMMMMNo .hMMh`
`yMMm/ .omMMMMMMMMMMMMMMMMMMMMd+``oNMNo
-hMMNo. -ohNMMMMMMMMMMMMmy+. -yNMNy`
.sNMMms/. `-/+++++/:-` ./yNMMmo`
:sdMMMNdyso+++ooshdNMMMdo-
`:+yhmNNMMMMNNdhs+-
```` ");
if (CurrentSave.Users.Count == 0)
{
CurrentSave.Users.Add(new ClientSave
{
Username = "******",
Password = "",
Permissions = UserPermissions.Root
});
Console.WriteLine("{MISC_NOUSERS}");
}
TerminalBackend.InStory = false;
TerminalBackend.PrefixEnabled = false;
if (LoginManager.ShouldUseGUILogin)
{
Action <ClientSave> Completed = null;
Completed += (user) =>
{
CurrentUser = user;
LoginManager.LoginComplete -= Completed;
};
LoginManager.LoginComplete += Completed;
Desktop.InvokeOnWorkerThread(() =>
{
LoginManager.PromptForLogin();
});
while (CurrentUser == null)
{
Thread.Sleep(10);
}
}
else
{
Login:
string username = "";
int progress = 0;
bool goback = false;
TextSentEventHandler ev = null;
string loginstr = Localization.Parse("{GEN_LPROMPT}", new Dictionary <string, string>
{
["%sysname"] = CurrentSave.SystemName
});
ev = (text) =>
{
if (progress == 0)
{
string getuser = text.Remove(0, loginstr.Length);
if (!string.IsNullOrWhiteSpace(getuser))
{
if (CurrentSave.Users.FirstOrDefault(x => x.Username == getuser) == null)
{
Console.WriteLine();
Console.WriteLine("{ERR_NOUSER}");
goback = true;
progress++;
TerminalBackend.TextSent -= ev;
return;
}
username = getuser;
progress++;
}
else
{
Console.WriteLine();
Console.WriteLine("{ERR_NOUSER}");
TerminalBackend.TextSent -= ev;
goback = true;
progress++;
}
}
else if (progress == 1)
{
string passwordstr = Localization.Parse("{GEN_PASSWORD}: ");
string getpass = text.Remove(0, passwordstr.Length);
var user = CurrentSave.Users.FirstOrDefault(x => x.Username == username);
if (user.Password == getpass)
{
Console.WriteLine();
Console.WriteLine("{GEN_WELCOME}");
CurrentUser = user;
progress++;
}
else
{
Console.WriteLine();
Console.WriteLine("{RES_DENIED}");
goback = true;
progress++;
}
TerminalBackend.TextSent -= ev;
}
};
TerminalBackend.TextSent += ev;
Console.WriteLine();
Console.Write(loginstr);
ConsoleEx.Flush();
while (progress == 0)
{
Thread.Sleep(10);
}
if (goback)
{
goto Login;
}
Console.WriteLine();
Console.Write("{GEN_PASSWORD}: ");
ConsoleEx.Flush();
while (progress == 1)
{
Thread.Sleep(10);
}
if (goback)
{
goto Login;
}
}
TerminalBackend.PrefixEnabled = true;
Shiftorium.LogOrphanedUpgrades = true;
Desktop.InvokeOnWorkerThread(new Action(() =>
{
ShiftOS.Engine.Scripting.LuaInterpreter.RunSft(Paths.GetPath("kernel.sft"));
}));
Desktop.InvokeOnWorkerThread(new Action(() => Desktop.PopulateAppLauncher()));
GameReady?.Invoke();
if (!string.IsNullOrWhiteSpace(CurrentSave.PickupPoint))
{
try
{
if (Story.Context == null)
{
Story.Start(CurrentSave.PickupPoint);
}
}
catch { }
}
}
public static void Detach_ServerManager_MessageReceived()
{
MessageReceived -= new ServerMessageReceived(ServerManager_MessageReceived);
}
protected override void Because()
{
this.result = (ServerMessageReceived)sut.MakeFrom("any message at all");
}
