private void ServerOnReceivedRequest(object sender, ReceivedRequestEventArgs e)
{
Log.Information("[PATCHERIPC] IPC: " + e.Request);
var msg = JsonConvert.DeserializeObject <PatcherIpcEnvelope>(PatcherMain.Base64Decode(e.Request), XIVLauncher.PatchInstaller.PatcherMain.JsonSettings);
switch (msg.OpCode)
{
case PatcherIpcOpCode.Hello:
_client.Initialize(XIVLauncher.PatchInstaller.PatcherMain.IPC_CLIENT_PORT);
Log.Information("[PATCHERIPC] GOT HELLO");
State = InstallerState.Ready;
break;
case PatcherIpcOpCode.InstallOk:
Log.Information("[PATCHERIPC] INSTALL OK");
State = InstallerState.Ready;
break;
case PatcherIpcOpCode.InstallFailed:
State = InstallerState.Failed;
MessageBox.Show(
"The patch installer ran into an error.\nPlease report this error.\nPlease use the official launcher.");
Stop();
Environment.Exit(0);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public ReceivedRequestEventArgs HandleRequest(ReceivedRequestEventArgs received)
{
Console.WriteLine("\t\t ---" + name);
if (received.Handled)
{
return(received);
}
var cmd = received.GetCmd(out var args);
if (cmd.Equals("fdlg"))
{
//if (args != null)
//{
var th = new Thread(() =>
{
OpenFileDialog odlg = new OpenFileDialog();
if (args.Length > 0)
{
odlg.Filter = args[0];
}
if (args.Length > 1)
{
odlg.Filter = args[0];
}
});
//}
}
return(received);
}
private static void ServerReceivedRequest(object sender, ReceivedRequestEventArgs e)
{
if (e.Handled)
{
return;
}
IpcMessage requestMessage = JsonConvert.DeserializeObject <IpcMessage>(e.Request);
switch (requestMessage.Type)
{
case IpcMessage.TcpMessageType.Command:
#region Handle IPC Commands
if (requestMessage.IsGetVersionMessage())
{
e.Response = version;
e.Handled = true;
return;
}
if (requestMessage.IsStopMessage())
{
stopEvent.Set();
e.Handled = true;
return;
}
#endregion
break;
case IpcMessage.TcpMessageType.Update:
HandleUpdate(requestMessage.Update);
e.Handled = true;
break;
}
}
private void ServerOnReceivedRequest(object sender, ReceivedRequestEventArgs e)
{
var projectLocation = _doc.ActiveProjectLocation;
Transform t = projectLocation.GetTotalTransform();
List <GeometryPoint[]> points = JsonConvert.DeserializeObject <List <GeometryPoint[]> >(e.Request);
List <List <XYZ> > s = points.Select(x =>
{
var p1 = ToXyz(x[0]);
var p2 = ToXyz(x[1]);
var p3 = ToXyz(x[2]);
var t1 = t.OfPoint(p1);
var t2 = t.OfPoint(p2);
var t3 = t.OfPoint(p3);
return(new List <XYZ> {
t1, t2, t3
});
})
.ToList();
Execute(s);
e.Handled = true;
}
private static void ServerOnReceivedRequest(object sender, ReceivedRequestEventArgs e)
{
Log.Information("[PATCHER] IPC: " + e.Request);
var msg = JsonConvert.DeserializeObject <PatcherIpcEnvelope>(Base64Decode(e.Request), JsonSettings);
switch (msg.OpCode)
{
case PatcherIpcOpCode.Bye:
Task.Run(() =>
{
Thread.Sleep(3000);
Environment.Exit(0);
});
break;
case PatcherIpcOpCode.StartInstall:
var installData = (PatcherIpcStartInstall)msg.Data;
_queuedInstalls.Enqueue(installData);
break;
case PatcherIpcOpCode.Finish:
var path = (DirectoryInfo)msg.Data;
VerToBck(path);
Log.Information("VerToBck done");
break;
}
}
private void IpcOnReceivedRequest(object sender, ReceivedRequestEventArgs e)
{
string filePath = e.Request;
_sandboxie.StartSandboxed(filePath);
e.Handled = true;
}
private void RadioReceiver(object sender, ReceivedRequestEventArgs args)
{
FMsg fMsg = JsonConvert.DeserializeObject <FMsg>(args.Request);
if (fMsg.Type.Equals("CMD"))
{
int b;
switch (fMsg.Data)
{
case "MinerActive":
b = (int)(FConstants.WorkerType)Enum.Parse(typeof(FConstants.WorkerType), fMsg.Data2);
if (b < s.MinerIsActive.Length)
{
s.MinerIsActive[b] = true;
}
UpdateMSGtoUI($"Miner is activated! - {fMsg.Data2}", FConstants.FreyaLogLevel.MinerInfo);
logger.WriteLine($"[Freya] Get CMD MinerActive. s.MinerIsActive {s.MinerIsActive[0]}|{s.MinerIsActive[1]}|{s.MinerIsActive[2]} -{b}");
args.Response = "UIOK1";
break;
case "MinerStop":
b = (int)(FConstants.WorkerType)Enum.Parse(typeof(FConstants.WorkerType), fMsg.Data2);
if (b < s.MinerIsActive.Length)
{
s.MinerIsActive[b] = false;
}
UpdateMSGtoUI($"Miner stopped! - {fMsg.Data2}", FConstants.FreyaLogLevel.MinerInfo);
logger.WriteLine($"[Freya] Get CMD MinerStop. s.MinerIsActive {s.MinerIsActive[0]}|{s.MinerIsActive[1]}|{s.MinerIsActive[2]} -{b}");
args.Response = "UIOK2";
break;
case "StartUpdateProcess":
args.Response = DeployWatchDog();
args.Handled = true;
ExitFreya();
break;
default:
args.Response = "UING";
break;
}
}
else if (fMsg.Type.Equals("MSG"))
{
Trace.WriteLine($@"[FreyaUI] Receive MSG: '{fMsg.Data}'.");
UpdateMSGtoUI(fMsg.Data, fMsg.Loglevel);
args.Response = FEnv.RADIO_OK;
}
else
{
Trace.WriteLine($@"[FreyaUI] Receive Unknown: '{args.Request}'.");
UpdateMSGtoUI(args.Request);
args.Response = "UIReceive Unknown";
}
args.Handled = true;
}
public ReceivedRequestEventArgs HandleRequest(ReceivedRequestEventArgs received)
{
Console.WriteLine("\t\t ---" + name);
if (received.Handled)
{
return(received);
}
Console.WriteLine(name + " REV:" + received.Request);
received.Response = "server has handled. and do not response";
received.Handled = true;
return(received);
}
private void Server_ReceivedRequest(object sender, ReceivedRequestEventArgs e)
{
var req = new DataStruct.ReceivedRequestEventArgs(e);
for (int i = 0; i < handles.Count; i++)
{
var req1 = req;
try
{
req = handles[i].HandleRequest(req);
}
catch (Exception ee)
{
req = req1;
errorHandler?.HandleExcep(ee);
}
}
req.Handled = true;
e = req.GetRequest();
}
public static string GetCmd(this ReceivedRequestEventArgs e, out string[] args)
{
string cmd = e.Request;
var ss = cmd.Split('|');
if (ss.Length > 1)
{
args = new string[ss.Length - 1];
for (int i = 0; i < args.Length; i++)
{
args[i] = ss[i + 1];
}
}
else
{
args = null;
}
return(ss[0]);
}
/// <summary>
/// Handles requests from the IPC server,
/// for things like opening in an existing process.
/// </summary>
private void IpcServer_ReceivedRequest(object sender, ReceivedRequestEventArgs e)
{
// Handle our IPC message
var message = JsonConvert.DeserializeObject <IpcMessage>(e.Request);
switch (message.Name)
{
// We have arguments from a starting process instance
case "ProcStartArgs":
var args = message.Payload as JArray;
var strArgs = args?.Select(i => (string)i).ToArray();
// Bring our window to focus
//Dispatcher.Invoke(() => { Activate(); });
HandleArguments(strArgs);
break;
default:
throw new InvalidOperationException("Invalid IPC message type!");
}
}
public ReceivedRequestEventArgs HandleRequest(ReceivedRequestEventArgs received)
{
Console.WriteLine("\t\t ---" + name);
if (received.Handled)
{
return(received);
}
string cmd = received.GetCmd(out var args);
if (cmd.Equals("x"))
{
Console.WriteLine(name + " REV:" + received.Request);
int a = int.Parse(args[0]);
int b = int.Parse(args[1]);
string result = string.Format("{0}x{1}={2}", a, b, a * b);
received.Response = result;
Console.WriteLine(result);
received.Handled = true;
}
return(received);
}
private void OnCommandReceived(object sender, ReceivedRequestEventArgs receivedRequestEventArgs)
{
throw new System.NotImplementedException();
}
private static void ServerOnReceivedRequest(object sender, ReceivedRequestEventArgs e)
{
Log.Information("[PATCHER] IPC: " + e.Request);
var msg = JsonConvert.DeserializeObject <PatcherIpcEnvelope>(Base64Decode(e.Request), JsonSettings);
switch (msg.OpCode)
{
case PatcherIpcOpCode.Bye:
Task.Run(() =>
{
Thread.Sleep(3000);
Environment.Exit(0);
});
break;
case PatcherIpcOpCode.StartInstall:
var installData = (PatcherIpcStartInstall)msg.Data;
// Ensure that subdirs exist
if (!installData.GameDirectory.Exists)
{
installData.GameDirectory.Create();
}
installData.GameDirectory.CreateSubdirectory("game");
installData.GameDirectory.CreateSubdirectory("boot");
Task.Run(() =>
InstallPatch(installData.PatchFile.FullName,
Path.Combine(installData.GameDirectory.FullName, installData.Repo == Repository.Boot ? "boot" : "game")))
.ContinueWith(t =>
{
if (!t.Result)
{
Log.Error(t.Exception, "PATCH INSTALL FAILED");
SendIpcMessage(new PatcherIpcEnvelope
{
OpCode = PatcherIpcOpCode.InstallFailed
});
}
else
{
try
{
installData.Repo.SetVer(installData.GameDirectory, installData.VersionId);
SendIpcMessage(new PatcherIpcEnvelope
{
OpCode = PatcherIpcOpCode.InstallOk
});
try
{
if (!installData.KeepPatch)
{
installData.PatchFile.Delete();
}
}
catch (Exception exception)
{
Log.Error(exception, "Could not delete patch file.");
}
}
catch (Exception ex)
{
Log.Error(ex, "Could not set ver file");
SendIpcMessage(new PatcherIpcEnvelope
{
OpCode = PatcherIpcOpCode.InstallFailed
});
}
}
});
break;
case PatcherIpcOpCode.Finish:
var path = (DirectoryInfo)msg.Data;
VerToBck(path);
Log.Information("VerToBck done");
break;
}
}
private void RadioReceiver(object sender, ReceivedRequestEventArgs args)
{
FMsg fMsg = JsonConvert.DeserializeObject <FMsg>(args.Request);
if (fMsg.Type.Equals("CMD"))
{
Console.WriteLine("Get CMD: " + fMsg.Data);
switch (fMsg.Data)
{
case "SetIdleTime":
foreach (Worker w in Workers)
{
if (w != null)
{
w.SetIdleTime(Convert.ToDouble(fMsg.Data2));
}
}
args.Response = JsonConvert.SerializeObject(s);
break;
case "GetWorkerStatus":
string workerstatus = "";
foreach (Worker w in Workers)
{
if (w != null)
{
if (w.Type == FConstants.WorkerType.CPU)
{
workerstatus += (w.isRunning)? "C:" : "c:";
}
else if (w.Type == FConstants.WorkerType.AMD)
{
workerstatus += (w.isRunning) ? "A:" : "a:";
}
else if (w.Type == FConstants.WorkerType.nVidia)
{
workerstatus += (w.isRunning) ? "N:" : "n:";
}
workerstatus = workerstatus + w.Message + "\n";
}
}
args.Response = workerstatus;
break;
case "MinerDisable":
foreach (Worker w in Workers)
{
if (w != null)
{
w.Enable = false;
}
}
s.MinerEnable = false;
args.Response = JsonConvert.SerializeObject(s);
break;
case "MinerEnable":
foreach (Worker w in Workers)
{
if (w != null)
{
w.Enable = true;
}
}
s.MinerEnable = true;
args.Response = JsonConvert.SerializeObject(s);
break;
case "GetStatus":
for (int w = 0; w < Workers.Length; w++)
{
if (Workers[w] != null)
{
s.MinerIsActive[w] = Workers[w].isRunning;
}
else
{
s.MinerIsActive[w] = false;
}
}
logger.WriteLine($"[Service] s.MinerIsActive {s.MinerIsActive[0]}|{s.MinerIsActive[1]}|{s.MinerIsActive[2]}");
args.Response = JsonConvert.SerializeObject(s);
break;
case "SetUIPort":
s.UIPort = Convert.ToInt32(fMsg.Data2);
radioClient.SetPort(s.UIPort);
FFunc.SetRegKey("FreyaUIPort", s.UIPort);
logger.WriteLine($"[Service] Receive UI Port at {s.UIPort}");
args.Response = JsonConvert.SerializeObject(s);
break;
case "RadioTest":
string ss = radioClient.Send(JsonConvert.SerializeObject(new FMsg {
Type = "MSG", Data = $"Service to UI radio test ... [Service Server Port {radioServer.Port}], [UI Port {radioClient.GetPort()}]", Loglevel = FConstants.FreyaLogLevel.FreyaInfo
}));
args.Response = $"[Service] s.MinerIsActive {s.MinerIsActive[0]}|{s.MinerIsActive[1]}|{s.MinerIsActive[2]}";
logger.WriteLine($"[Service] RadioTest sUIPort: {s.UIPort}, GetPort:{radioClient.GetPort()}");
break;
case "StartProxy":
StartProxies();
args.Response = "OK";
break;
case "StopProxy":
StopProxies();
args.Response = "OK";
break;
case "WriteRegistry":
if (fMsg.Data2.Length > 0)
{
RegSetting.SetSettingsToRegisry(fMsg.Data2);
args.Response = "OK";
logger.WriteLine("[Service] Options writed to registry.");
}
else
{
args.Response = "NG";
}
s.UpdateMinerSwitch();
foreach (Worker w in Workers)
{
if (w != null)
{
w.AlwaysRun = RegSetting.hasRight(FConstants.FeatureByte.AlwaysRun) ? true : false;
}
}
string strbuf = "";
foreach (bool s in s.MinerSwitch)
{
strbuf = strbuf + s.ToString() + " |";
}
logger.WriteLine($"[Service] WorkerSwitch : {strbuf}");
break;
default:
args.Response = "SCNG";
break;
}
}
else
{
args.Response = "SCNG1";
}
args.Handled = true;
}
public ReceivedRequestEventArgs HandleRequest(ReceivedRequestEventArgs received)
{
Console.WriteLine("___________________________________________RECEIVE CMD_______________________________________");
return(received);
}
