private void InjectIntoProcess(int targetPID, string targetProcessName)
{
if (_crashList.Contains(targetProcessName))
{
return;
}
Thread.Sleep(1000);
try
{
Log($"Attempting to inject into process {targetProcessName}, PID {targetPID}");
string channelName = null;
ServerInterface server = new ServerInterface(Log, RemoveServer, ShouldAbort);
RemoteHooking.IpcCreateServer(ref channelName, WellKnownObjectMode.Singleton, server);
RemoteHooking.Inject(
targetPID,
InjectionOptions.DoNotRequireStrongName,
_injectionLibraryPath,
_injectionLibraryPath,
channelName);
_servers.AddOrUpdate(targetPID, server, (pid, s) => server);
}
catch (Exception ex)
{
Log($"Error: {ex}");
_crashList.Add(targetProcessName);
}
}
public void Start(ushort port, ushort maxConnections, String pw)
{
pw = "ver2.081" + pw;
SocketDescriptor socketDescriptor = new SocketDescriptor();
socketDescriptor.port = port;
bool started = ServerInterface.Startup(maxConnections, socketDescriptor, 1) == StartupResult.RAKNET_STARTED;
ServerInterface.SetMaximumIncomingConnections(maxConnections);
ServerInterface.SetOccasionalPing(true);
if (pw.Length != 0)
{
ServerInterface.SetIncomingPassword(pw, pw.Length);
}
if (!started)
{
Log.Logger.logError("Port is already in use");
}
else
{
Log.Logger.log("Server start listening on port " + port);
}
}
internal virtual ServerInterface ServerInOtherJvm(int port)
{
ServerInterface server = (new MadeUpServerProcess()).Start(new StartupData(StoreIdConflict.CreationTime, StoreIdConflict.RandomId, InternalProtocolVersionConflict, ApplicationProtocolVersionConflict, ChunkSizeConflict, port));
server.AwaitStarted();
return(server);
}
public void ping()
{
for (int i = 0; i < knownProcesses.Count; i++)
{
string alive;
try
{
if (knownProcesses[i].getId().Equals("server"))
{
ServerInterface s = (ServerInterface)Activator.GetObject(
typeof(ServerInterface),
knownProcesses[i].getUrl());
//alive = s.ping();
}
else
{
ClientInterface c = (ClientInterface)Activator.GetObject(
typeof(ClientInterface),
knownProcesses[i].getUrl());
// alive = c.ping();
}
// if (!alive.Equals("alive")) {
//todo
// }
}
catch (Exception e) {
knownProcesses[i].addFail(new Fail());
}
}
}
private static void Main(string[] args)
{
AppDomain.CurrentDomain.ProcessExit += CurrentDomain_ProcessExit;
Process process = null;
while (process == null)
{
process = Process.GetProcessesByName("Warframe.x64").FirstOrDefault();
}
string channelName = null;
string libraryPath = "WfDx.dll";
RemoteHooking.IpcCreateServer <ServerInterface>(ref channelName, WellKnownObjectMode.Singleton);
client = RemoteHooking.IpcConnectClient <ServerInterface>(channelName);
try
{
RemoteHooking.Inject(process.Id, libraryPath, libraryPath, channelName);
Console.ReadLine();
client.RunLibrary = false;
}
catch (Exception e)
{
Console.WriteLine($"Something goes wrong {e}");
}
}
// Load scripts
void InitializeScripts()
{
// --- Web sockets
serverInterface = new ServerInterface();
serverInterface.Initialize();
// --- Interfaces
List<UIBase> interfaces = new List<UIBase>();
// Dashboard
UIBase dashboard = interfaceObject.GetComponent<DashboardUI>();
dashboard.Initialize();
interfaces.Add(dashboard);
// Facebook
UIBase facebookPanel = interfaceObject.GetComponent<FacebookPanel>();
dashboard.Initialize();
interfaces.Add(dashboard);
activeInterfaces = interfaces.ToArray();
// --- Events
eventProcessor = eventProcessorObject.GetComponent<EventProcessor>();
eventProcessor.Initialize();
// --- Get main page content
//Debug.Log("pinging server for content....");
}
public ServerInterface getServer(string server_url)
{
ServerInterface server = null;
try
{
server = (ServerInterface)Activator.GetObject(typeof(ServerInterface), server_url);
}
catch (Exception)
{
Console.WriteLine("trying new server");
string serversList = "servers.txt";
string[] serversURLs = File.ReadAllLines(serversList);
foreach (string url in serversURLs)
{
if (url != this.preferedServerUrl)
{
try
{
server = (ServerInterface)Activator.GetObject(typeof(ServerInterface), url);
this.setPreferedServerUrl(url);
Console.WriteLine("the new server is {0}", url);
return(server);
}
catch (Exception)
{
continue;
}
}
}
}
return(server);
}
public ServerInterface Execute()
{
int client_number, n_replicas, try_replica;
string server_url;
client_number = Int32.Parse(this.clientLibrary.ClientIdentifier.Remove(0, 1));
n_replicas = this.clientLibrary.NReplicas;
Console.WriteLine("Server knows \"" + client_number + "\" clients...");
Console.WriteLine("Server has \"" + n_replicas + "\" replicas...");
try_replica = (client_number % n_replicas) + 1;
Console.WriteLine("Since current replica has failed will try to connect to replica \"" + try_replica + "\"...");
for (int i = 0; i < n_replicas; i++)
{
server_url = "tcp://localhost:" + (try_replica + 3000) + "/Server" + try_replica;
Console.WriteLine("Replica url: \"" + server_url + "\".");
try
{
this.clientLibrary.ServerURL = server_url;
this.remote_server = (ServerInterface)Activator.GetObject(typeof(ServerInterface), server_url);
this.remote_server.IsAlive();
break;
}
catch (Exception exception) when(exception is System.Net.Sockets.SocketException || exception is System.IO.IOException)
{
try_replica = ((try_replica + 1) % n_replicas) + 1;
Console.WriteLine(try_replica);
}
}
return(this.remote_server);
}
public void processCommand(string line)
{
string[] linesplit = line.Split(null);
if (linesplit[0].Equals("skip"))
{
return;
}
else if (linesplit[0].Equals("GlobalStatus")) //globalstatus on client!!! improve globalstatus on server
{
globalStatus();
}
else if (linesplit[0].Equals("Crash")) //CRASH PID
{
if (serversUrl.Contains(mapa[linesplit[1]]))
{
ServerInterface s = (ServerInterface)Activator.GetObject(
typeof(ServerInterface),
mapa[linesplit[1]]);
s.crash();
serversUrl.Remove(mapa[linesplit[1]]);
mapa.Remove(linesplit[1]);
}
else if (clientsUrl.Contains(mapa[linesplit[1]]))
{
ClientInterface c = (ClientInterface)Activator.GetObject(
typeof(ClientInterface),
mapa[linesplit[1]]);
c.crash();
clientsUrl.Remove(mapa[linesplit[1]]);
mapa.Remove(linesplit[1]);
}
}
else if (linesplit[0].Equals("LocalState")) /*todo*/ } {
public void Disconnect()
{
if (this.servInterface != null) {
this.servInterface.Disconnect();
this.servInterface = null;
}
}
public RequestStatus SendCloseRequest(MarketOrder order, PositionExitReason reason)
{
// получить счет
RequestStatus error;
var acDecorated = ServerInterface.GetAccount(order.AccountID);
if (acDecorated == null)
{
return(RequestStatus.ServerError);
}
// подготовить запрос
TradeSharp.ProviderProxyContract.Entity.MarketOrder request;
if (!MakeMarketRequest(acDecorated, order.Symbol, order.Magic, order.Volume, -order.Side,
OrderType.Market,
0, 0,
string.Format("close order #{0}", order.ID),
order.ID, order.Comment, order.ExpertComment, order.TrailLevel1, order.TrailTarget1,
out error, out request))
{
return(error);
}
exitReasonByOrderId.UpdateValues(order.ID, reason);
// отправить запрос на вход в рынок (оно же - закрытие позиции) в соотв сессию
if (!request.SendToQueue(false))
{
errorStorage.AddMessage(new ErrorMessage(DateTime.Now, ErrorMessageType.ОшибкаОтправки,
"Невозможно отправить сообщение (CloseOrder) в очередь MQ", null));
return(RequestStatus.DealerError);
}
return(RequestStatus.OK);
}
private bool IsOverflooded(TradeTransactionRequest request, MarketOrder order)
{
try
{
var isFlooded = RequestStorage.Instance.CheckOverflood();
if (isFlooded)
{
var errorResponse = new BrokerService.Contract.Entity.BrokerResponse
{
AccountId = request.Account,
Mt4OrderId = request.ClosingPositionId ?? 0,
RejectReason = OrderRejectReason.UnableMassCancel,
Status = OrderStatus.Rejected,
RejectReasonString = "overflood",
RequestId = request.Id,
ValueDate = DateTime.Now
};
ServerInterface.NotifyClientOnOrderRejected(order, errorResponse.RejectReasonString);
return(true);
}
}
catch (Exception ex)
{
Logger.Error("Error in CheckOverflood()", ex);
return(true);
}
return(false);
}
public List <string> getClientsForGossip()
{
SortedSet <string> result = new SortedSet <string>();
string serversList = "servers.txt";
string[] serversURLs = File.ReadAllLines(serversList);
foreach (string url in serversURLs)
{
try
{
ServerInterface server = (ServerInterface)Activator.GetObject(typeof(ServerInterface), url);
string suggested_client = server.getRandomClient();
result.Add(suggested_client);
}
catch (Exception)
{
continue;
}
}
List <string> results_list = new List <string>();
foreach (string client in result)
{
results_list.Add(client);
}
return(results_list);
}
public void informServers()
{
this.setNodes();
List <string> nodesToRemove = new List <string>();
foreach (string url in this.servers)
{
ServerInterface server = null;
try
{
server = (ServerInterface)Activator.GetObject(typeof(ServerInterface), url);
if (server != null)
{
server.addClient(this.url);
}
else
{
nodesToRemove.Add(url);
}
}
catch (Exception)
{
nodesToRemove.Add(url);
}
}
foreach (string node in nodesToRemove)
{
this.servers.Remove(node);
}
}
public ClientHandler(TcpClient client, ServerInterface sender)
{
this.client = client;
this.sender = sender;
clientIp = ((IPEndPoint)client.Client.RemoteEndPoint).Address.ToString();
setTimer();
}
// Use this for initialization
void Start()
{
serverInterface = GetComponent <ServerInterface>();
panelQuitConfirm.SetActive(false);
loginListPanel.gameObject.SetActive(false);
refreshButton.SetActive(false);
connectButton.SetActive(false);
createButton.SetActive(false);
userCreateMessagePanel.SetActive(false);
panelLobbyReady.SetActive(false);
titleTextText = titleText.GetComponent <Text>();
titleTextRect = titleText.GetComponent <RectTransform>();
qButtonRect = quitButton.gameObject.GetComponent <RectTransform>();
lButtonRect = loginButton.GetComponent <RectTransform>();
sButtonRect = settingsButton.GetComponent <RectTransform>();
userCreateOkButton.onClick.AddListener(CloseUserCreation);
loginButton.GetComponent <Button>().onClick.AddListener(Login);
createUserButton.GetComponent <Button>().onClick.AddListener(UserCreation);
quitButton.GetComponent <Button>().onClick.AddListener(QuitConfirmation);
refreshButton.GetComponent <Button>().onClick.AddListener(RefreshList);
createButton.GetComponent <Button>().onClick.AddListener(CreateLobby);
}
static void Main(string[] args)
{
try
{
if (Properties.Settings.Default.UpgradeRequired)
{
Properties.Settings.Default.Upgrade();
Properties.Settings.Default.UpgradeRequired = false;
Properties.Settings.Default.Save();
}
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
ServerInterface.SetBadCertificateHandler(BadCertificateHandler);
var login = new Login();
login.Show();
Application.Run();
}
catch (Exception e)
{
ServiceDisconnectException(e);
}
finally
{
Properties.Settings.Default.Save();
}
}
public Simulator(ServerInterface serverInterface, string name, string description)
{
this.simId = serverInterface.StartSim(name, description);
this.simInterface = serverInterface.ConnectToSim(this.simId);
this.Init();
this.log = new SimulatorLog(this.simInterface);
}
public ushort ConnectionCount()
{
SystemAddress[] sa = null;
ushort numbers = 0;
ServerInterface.GetConnectionList(out sa, ref numbers);
return(numbers);
}
public void Connect(String server_URL)
{
Server = (ServerInterface)Activator.GetObject(
typeof(ServerInterface),
server_URL);
this.Server_url = server_URL;
Console.WriteLine("Registei o servidor. Sou o/a " + this.UserName);
}
public Simulator(ServerInterface serverInterface, string simId)
{
this.simId = simId;
this.simInterface = serverInterface.ConnectToSim(this.simId);
this.Init();
this.log = new SimulatorLog(this.simInterface);
}
// TODO: Create a channel for sending messages back and forth between this and LiveSplit
public LiveSplitHelper(Process liveSplitProcess, string channelName, ServerInterface server)
{
_liveSplitProcess = liveSplitProcess;
_windowBitmap = null;
_server = server;
Task.Run(WindowGrabBackgroundTask);
}
public void TestCopyRemoteInterface()
{
var first = CreateFakeRemoteInterface();
var second = new ServerInterface(first);
Assert.AreEqual(first.HTTPSURL, second.HTTPSURL);
Assert.AreEqual(first.HTTPSPort, second.HTTPSPort);
Assert.IsTrue(second.IsRemoteConnection);
}
public void RequestProcessed(BrokerService.Contract.Entity.BrokerResponse response)
{
var request = RequestStorage.Instance.FindRequest(response.RequestId);
if (request == null)
{
Logger.Info("MT4 executor - исходный запрос не найден: " + response);
return;
}
Logger.Info("Ответ MT4 executor: " + response);
if (response.Status != OrderStatus.Executed)
{
return;
}
// закрытие ордера
if (request.request.IsClosingRequest)
{
if (!response.Price.HasValue)
{
Logger.Error("Ответ MT4 executor - закрытие позиции - нет цены");
return;
}
ServerInterface.CloseOrder(request.requestedOrder.ID,
response.Price.Value, PositionExitReason.Closed);
return;
}
// открытие ордера
if (!response.Price.HasValue)
{
response.RejectReason = OrderRejectReason.UnknownOrder;
}
if (response.RejectReason.HasValue && response.RejectReason.Value != OrderRejectReason.None)
{
ServerInterface.NotifyClientOnOrderRejected(request.requestedOrder,
response.RejectReasonString);
Logger.DebugFormat("{0}: order {1} is rejected for reason {2}",
DealerCode, request.requestedOrder.ToStringShort(), response.RejectReason);
return;
}
var order = request.requestedOrder;
order.PriceEnter = (float)response.Price.Value;
order.AccountID = request.request.Account;
order.TimeEnter = DateTime.Now;
order.State = PositionState.Opened;
order.MasterOrder = response.Mt4OrderId;
int openedOrderId;
ServerInterface.SaveOrderAndNotifyClient(order, out openedOrderId);
}
public void informOtherServers(Command command)
{
Console.WriteLine("Inform other servers");
// passive replication strategy
if (command.isSentByClient())
{
if (command.getType() == "CREATE" || command.getType() == "JOIN" || command.getType() == "CLOSE")
{
foreach (string serverURL in this.servers)
{
// TODO Asynchronous calls maybe a better idea
if (serverURL != this.url)
{
try
{
ServerInterface server = (ServerInterface)Activator.GetObject(typeof(ServerInterface), serverURL);
switch (command.getType())
{
case "CREATE":
command.setSentByClient(false);
CreateRemoteAsyncDelegate RemoteDel = new CreateRemoteAsyncDelegate(server.execute);
IAsyncResult RemAr = RemoteDel.BeginInvoke((CreateCommand)command, null, null);
// server.execute((CreateCommand)command);
break;
case "JOIN":
command.setSentByClient(false);
JoinRemoteAsyncDelegate RemoteDel2 = new JoinRemoteAsyncDelegate(server.execute);
IAsyncResult RemAr2 = RemoteDel2.BeginInvoke((JoinCommand)command, null, null);
// server.execute((JoinCommand)command);
break;
case "CLOSE":
command.setSentByClient(false);
CloseRemoteAsyncDelegate RemoteDel3 = new CloseRemoteAsyncDelegate(server.execute);
IAsyncResult RemAr3 = RemoteDel3.BeginInvoke((CloseCommand)command, null, null);
// server.execute((CloseCommand)command);
break;
default:
break;
}
}
catch (Exception)
{
Console.WriteLine(serverURL + " FAULT");
// Faults tolerance TODO
}
}
}
}
}
}
public InjectionEntryPoint(
EasyHook.RemoteHooking.IContext context,
string channelName)
{
_server = EasyHook.RemoteHooking.IpcConnectClient <ServerInterface>(channelName);
// If Ping fails then the Run method will be not be called
_server.Ping();
}
public void TestSetBadCertificateHandler()
{
Func <string, bool> func = (message) =>
{
Assert.IsFalse(String.IsNullOrWhiteSpace(message));
return(true);
};
ServerInterface.SetBadCertificateHandler(func);
}
public void Inject(string processName)
{
if (Injected)
{
return;
}
var process = Process.GetProcessesByName(processName)
.FirstOrDefault() ?? throw new AppException($"无法找到正在运行的 {processName} 应用.");
if (!RemoteHooking.IsAdministrator)
{
// Please run the program as an administrator
throw new AppException("请以管理员身份运行程序.");
}
if (Parameter.DirectXVersion == DirectXVersion.Unkonwn)
{
Parameter.DirectXVersion = GetCurrentDirectXVerion(process);
}
logger.Info($"Current DirectX version is {Parameter.DirectXVersion}.");
var injectionLibrary = typeof(InjectEntryPoint).Assembly.Location;
var server = new ServerInterface(logger);
string channelName = null;
RemoteHooking.IpcCreateServer(
ref channelName, System.Runtime.Remoting.WellKnownObjectMode.Singleton, server);
Parameter.ChannelName = channelName;
try
{
logger.Info($"Attemption to inject into process {process.ProcessName}({process.Id})");
RemoteHooking.Inject(
process.Id,
injectionLibrary,
injectionLibrary,
Parameter
);
Injected = true;
this.server = server;
}
catch (Exception ex)
{
logger.Error("There was an error while injecting into target:", ex);
}
// 锁头
Detect(process.MainWindowHandle);
screenCapture.SetForegroundWindow(process.MainWindowHandle);
}
public override RequestStatus ModifyMarketOrderRequest(MarketOrder order)
{
var status = ServerInterface.ModifyMarketOrder(order)
? RequestStatus.OK : RequestStatus.ServerError;
if (status == RequestStatus.OK)
{
SendRequest(order, "modify");
}
return(status);
}
private void connectToServer(int port)
{
TcpChannel channel = new TcpChannel(port);
ChannelServices.RegisterChannel(channel, false);
serverInterface = (ServerInterface)
Activator.GetObject(typeof(ServerInterface),
"tcp://localhost:8086/ServerObject");
clientObject = new ClientObject(this, serverInterface);
RemotingServices.Marshal(clientObject, "ClientObject",
typeof(ClientObject));
}
internal void CvarValue(Edict.Native *pEnt, string value)
{
try
{
ServerInterface.CvarValue(EntityDictionary.EdictFromNative(pEnt), value);
}
catch (Exception e)
{
Log.Exception(e);
throw;
}
}
internal void CvarValue2(Edict.Native *pEnt, int requestID, string cvarName, string value)
{
try
{
ServerInterface.CvarValue2(EntityDictionary.EdictFromNative(pEnt), requestID, cvarName, value);
}
catch (Exception e)
{
Log.Exception(e);
throw;
}
}
public void ImAlive(int tServerId, string address)
{
_timers[tServerId].Interval = TIMEOUT;
if (!_transactionalServers.ContainsKey(tServerId))
{
_transactionalServers.Add(tServerId, address);
}
ServerInterface server = (ServerInterface)Activator.GetObject(typeof(ServerInterface), address);
Console.WriteLine("server " + tServerId + " says: ALIVE");
}
public void TestBadCertificateHandler()
{
var ran = false;
ServerInterface.SetBadCertificateHandler(_ =>
{
ran = true;
return(true);
});
ServicePointManager.ServerCertificateValidationCallback(this, new System.Security.Cryptography.X509Certificates.X509Certificate(), new System.Security.Cryptography.X509Certificates.X509Chain(), System.Net.Security.SslPolicyErrors.RemoteCertificateChainErrors);
Assert.IsTrue(ran);
}
private void button1_Click(object sender, EventArgs e)
{
int port = int.Parse(textBox1.Text);
TcpChannel channel = new TcpChannel(port);
ChannelServices.RegisterChannel(channel, false);
RemoteClient rc = new RemoteClient();
RemotingServices.Marshal(rc, "ChatClient", typeof(RemoteClient));
server = (ServerInterface)Activator.GetObject(
typeof(ServerInterface),
"tcp://localhost:8086/ChatServer");
try
{
server.Connect(port);
}
catch (SocketException)
{
System.Console.WriteLine("Could not locate server");
}
}
public override void handleServerSide(ServerInterface serverInterface)
{
serverInterface.login(username, password);
}
public override void handleServerSide(ServerInterface serverInterface)
{
serverInterface.ReceiveMeasurement(measurement, physicianName, sessionType, username);
}
public override void handleServerSide(ServerInterface serverInterface)
{
serverInterface.recievePacketHistory(List, username);
}
public override void handleServerSide(ServerInterface serverInterface)
{
serverInterface.receivePacketSession(this);
}
public override void handleServerSide(ServerInterface serverInterface)
{
serverInterface.AddUser(user,physicianName);
}
public override void handleServerSide(ServerInterface serverInterface)
{
serverInterface.ChatMessage(sender, receiver, message);
}
public override void handleServerSide(ServerInterface serverInterface)
{
serverInterface.receiveChatPacket(this);
}
public override void handleServerSide(ServerInterface serverInterface)
{
serverInterface.Broadcast(sender, message);
}
public virtual void handleServerSide(ServerInterface serverInterface)
{
}
public override void handleServerSide(ServerInterface serverInterface)
{
serverInterface.SaveWerkbon(werkbon);
}
public void Connect(String username, String server, int port)
{
this.servInterface = new ServerInterface(username, server, port);
this.simulators = new List<Simulator>();
this.refreshSimsList();
}
public override void handleServerSide(ServerInterface serverInterface)
{
serverInterface.SaveData();
}
public override void handleServerSide(ServerInterface serverInterface)
{
serverInterface.AddUser(user);
}
public override void handleServerSide(ServerInterface serverInterface)
{
serverInterface.NewUsers(users);
}
public override void handleServerSide(ServerInterface serverInterface)
{
serverInterface.GetWerkbonnen();
}
public override void handleServerSide(ServerInterface serverInterface)
{
serverInterface.GetUsers();
}
public override void handleServerSide(ServerInterface serverInterface)
{
serverInterface.recieveLoadFile(this);
}
public override void handleServerSide(ServerInterface serverInterface)
{
serverInterface.receivePacketBicycleCommand(this);
}
public override void handleServerSide(ServerInterface serverInterface)
{
serverInterface.sendMeasurementList();
}
public override void handleServerSide(ServerInterface serverInterface)
{
serverInterface.ReceiveMeasurement(measurement, physicianName, training);
}
bool ConnectToServer()
{
bool success = false;
try
{
remoteObject = (ServerInterface)Activator.GetObject(typeof(ServerInterface),
"tcp://" + ServerIP + ":" + ServerPort + "/" + ServerServiceName);
success = true;
}
catch (System.Net.Sockets.SocketException sock)
{
MessageBox.Show("SocketException: Server Is not Running");
}
catch (System.Reflection.TargetInvocationException tg)
{
MessageBox.Show("TargetInvocationException");
}
return success;
}
public override void handleServerSide(ServerInterface serverInterface)
{
serverInterface.GiveUser(username, allUsers, physicianName);
}
public EgonServer(string releasePath)
{
this.servInterface = null;
this.releasePath = releasePath;
}
public override void handleServerSide(ServerInterface serverInterface)
{
serverInterface.NewWerkbonnen(werkbonnen);
}
public override void handleServerSide(ServerInterface serverInterface)
{
serverInterface.BikeValues(power, time, distance, username);
}
