// Done!
private static void CommandTesterHelper(string s, EventHandler <MessageEventArgs> call)
{
// Vamos enviar isto!
IList <AsyncDataEventArgs> data = FragmentAssyncDataCollection(ConvertToAssyncDataCollection(RandomSplit(s)));
AsyncStreamReader ar = CreateAsyncStreamReader();
MessengerReader mr = new MessengerReader(ar);
bool done = false;
mr.MessageReceived += (o, e) =>
{
call.Invoke(o, e);
done = true;
};
// Send data!
for (int i = 0; i < data.Count; ++i)
{
ar.Invoke(data[i]);
}
int time = Environment.TickCount;
while (done == false)
{
Thread.Sleep(20);
if (Environment.TickCount - time > 2000)
{
throw new AssertionException("Could not complete operation on time");
}
}
}
private void OpenConnection(Connection connection, string data, Action initializeCallback, Action<Exception> errorCallback)
{
var url = connection.Url + GetReceiveQueryString(connection, data);
Action<HttpWebRequest> prepareRequest = PrepareRequest(connection);
HttpHelper.GetAsync(url, request =>
{
prepareRequest(request);
request.Accept = "text/event-stream";
if (connection.MessageId != null)
{
request.Headers["Last-Event-ID"] = connection.MessageId.ToString();
}
}).ContinueWith(task =>
{
if (task.IsFaulted)
{
errorCallback(task.Exception);
}
else
{
// Get the reseponse stream and read it for messages
var stream = task.Result.GetResponseStream();
var reader = new AsyncStreamReader(stream, connection, initializeCallback, errorCallback);
reader.StartReading();
// Set the reader for this connection
connection.Items[ReaderKey] = reader;
}
});
}
private void OpenConnection(Connection connection, string data, Action initializeCallback, Action <Exception> errorCallback)
{
var url = connection.Url + GetReceiveQueryString(connection, data);
Action <HttpWebRequest> prepareRequest = PrepareRequest(connection);
HttpHelper.GetAsync(url, request =>
{
prepareRequest(request);
request.Accept = "text/event-stream";
if (connection.MessageId != null)
{
request.Headers["Last-Event-ID"] = connection.MessageId.ToString();
}
}).ContinueWith(task =>
{
if (task.IsFaulted)
{
errorCallback(task.Exception);
}
else
{
// Get the reseponse stream and read it for messages
var stream = task.Result.GetResponseStream();
var reader = new AsyncStreamReader(stream, connection, initializeCallback, errorCallback);
reader.StartReading();
// Set the reader for this connection
connection.Items[ReaderKey] = reader;
}
});
}
public static Task <string> ReadAsString(this IResponse response, Func <ArraySegment <byte>, bool> onChunk)
{
if (response == null)
{
throw new ArgumentNullException("response");
}
var stream = response.GetStream();
var reader = new AsyncStreamReader(stream);
var result = new StringBuilder();
var resultTcs = new TaskCompletionSource <string>();
reader.Data = buffer =>
{
if (onChunk(buffer))
{
result.Append(Encoding.UTF8.GetString(buffer.Array, buffer.Offset, buffer.Count));
}
};
reader.Closed = exception =>
{
response.Dispose();
resultTcs.SetResult(result.ToString());
};
reader.Start();
return(resultTcs.Task);
}
/// <summary>
/// Create a set of readers to read the specified streams, handles are assigned
/// based upon the index of each stream in the provided array.
/// </summary>
/// <param name="streams">Streams to read.</param>
/// <param name="bufferSize">Size of the buffer to use to read each stream.</param>
public static AsyncStreamReader[] CreateFromStreams(Stream[] streams, int bufferSize)
{
AsyncStreamReader[] readers = new AsyncStreamReader[streams.Length];
for (int i = 0; i < streams.Length; i++)
{
readers[i] = new AsyncStreamReader(i, streams[i], bufferSize);
}
return(readers);
}
protected void OpenLisp()
{
// Close the lisp process if one has already
// been started.
CloseLisp();
if (String.IsNullOrEmpty(this.LispPath))
{
throw new NullReferenceException("The Lisp Path cannot be empty or null.");
}
this.Scintilla.Text = String.Empty;
try
{
// Redirect the output stream of the child process.
this.lispProcess.StartInfo.UseShellExecute = false;
this.lispProcess.StartInfo.RedirectStandardOutput = true;
this.lispProcess.StartInfo.RedirectStandardError = true;
this.lispProcess.StartInfo.RedirectStandardInput = true;
this.lispProcess.StartInfo.CreateNoWindow = true;
this.lispProcess.EnableRaisingEvents = true;
this.lispProcess.Exited += new EventHandler(lispProcess_Exited);
this.lispProcess.ErrorDataReceived += new DataReceivedEventHandler(lispProcess_ErrorDataReceived);
this.lispProcess.StartInfo.FileName = this.LispPath;
// Start the child process.
this.lispProcess.Start();
this.stdInWriter = this.lispProcess.StandardInput;
this.stdOutReader = this.lispProcess.StandardOutput;
this.output = new AsyncStreamReader(this.lispProcess, this.stdOutReader.BaseStream,
new UserCallBack(this.SetTextCallback), this.stdOutReader.CurrentEncoding);
this.output.BeginRead();
this.lispProcess.BeginErrorReadLine();
started = true;
}
catch (Exception e)
{
this.Scintilla.InsertText("\r\nError starting REPL process.\r\n");
this.Scintilla.InsertText(e.Message);
throw e;
}
}
private void btnBuildBackend_Click(object sender, EventArgs e)
{
Process process = new Process();
ProcessStartInfo psi = new ProcessStartInfo {
FileName = "cmd.exe",
Arguments = "/C dotnet publish -c release -r ubuntu.18.04-x64",
WorkingDirectory = Program.config.BackendSourceDirectory,
WindowStyle = ProcessWindowStyle.Hidden,
CreateNoWindow = true,
UseShellExecute = false,
RedirectStandardError = true,
RedirectStandardOutput = true,
};
process.StartInfo = psi;
process.EnableRaisingEvents = true;
process.Exited += delegate {
CleanWriteToLog("\n============================================================\n");
};
CleanWriteToLog("\n============================================================\r\nStarting Backend Build\r\n============================================================\n");
process.Start();
AsyncStreamReader standardOutput = new AsyncStreamReader(process.StandardOutput);
AsyncStreamReader standardError = new AsyncStreamReader(process.StandardError);
standardOutput.DataReceived += (send, data) => {
if (data != null)
{
CleanWriteToLog(data);
}
};
standardError.DataReceived += (send, data) => {
if (data != null)
{
CleanWriteToLog(data);
}
};
standardOutput.Start();
standardError.Start();
}
internal CouchContinuousChanges(DreamMessage aMessage, CouchChangeDelegate aCallback)
{
if (aMessage == null)
{
throw new ArgumentNullException("aMessage");
}
if (aCallback == null)
{
throw new ArgumentNullException("aCallback");
}
theReader = new AsyncStreamReader(aMessage.ToStream(), (x, y) => {
if (!String.IsNullOrEmpty(y.Line))
{
CouchChangeResult result = theSerializer.Deserialize(y.Line);
aCallback(this, result);
}
});
}
public AsyncServerStreamingCall <SimpleResponse> ServerStreamingMethodSync(SimpleRequest request, CallSettings callSettings)
{
CallTimes.Add(_scheduler.Clock.GetCurrentDateTimeUtc());
CallSettingsReceived.Add(callSettings);
var responseStream = new AsyncStreamReader <SimpleResponse>(new SimpleResponse {
Name = request.Name
});
var responseHeaders = Task.Run(async() =>
{
await _scheduler.Delay(_callDuration, callSettings.CancellationToken.GetValueOrDefault());
if (_failuresToReturn > 0)
{
_failuresToReturn--;
throw new RpcException(new Status(_failureCode, "Bang"));
}
return(Metadata.Empty);
});
var response = new AsyncServerStreamingCall <SimpleResponse>(responseStream, responseHeaders, null, null, null);
return(response);
}
private static void CallCLI(string name, string args)
{
UpdateConsoleOut($"> Starting {name} with {args}");
UpdateConsoleOut($"{Environment.NewLine}");
var procStartInfo = new ProcessStartInfo(name)
{
RedirectStandardOutput = true,
RedirectStandardError = true,
CreateNoWindow = true,
UseShellExecute = false,
Arguments = args
};
var proc = Process.Start(procStartInfo);
var standardOutput = new AsyncStreamReader(proc.StandardOutput);
var standardError = new AsyncStreamReader(proc.StandardError);
standardOutput.DataReceived += (sender, data) =>
{
UpdateConsoleOut(data);
};
standardError.DataReceived += (sender, data) =>
{
Log.StaticLog.AddEntry(LogEntry.ErrorEntry("CallCLI", $"Command [{name} {args}] resulted in ERROR"));
UpdateConsoleOut(data);
};
standardOutput.Start();
standardError.Start();
Log.StaticLog.AddEntry(LogEntry.TraceEntry("CallCLI", $"command: {name} {args}"));
proc.WaitForExit();
proc.Close();
UpdateConsoleOut($"{Environment.NewLine}");
standardOutput.Stop();
standardError.Stop();
}
/// <summary>
/// Execute a command line tool.
/// </summary>
/// <param name="toolPath">Tool to execute. On Windows, if the path to this tool contains
/// single quotes (apostrophes) the tool will be executed via the shell.</param>
/// <param name="arguments">String to pass to the tools' command line.</param>
/// <param name="workingDirectory">Directory to execute the tool from.</param>
/// <param name="envVars">Additional environment variables to set for the command.</param>
/// <param name="ioHandler">Allows a caller to provide interactive input and also handle
/// both output and error streams from a single delegate. NOTE: This is ignored if
/// shell execution is enabled.</param>
/// <param name="useShellExecution">Execute the command via the shell. This disables
/// I/O redirection and causes a window to be popped up when the command is executed.
/// This uses file redirection to retrieve the standard output stream.
/// </param>
/// <param name="stdoutRedirectionInShellMode">Enables stdout and stderr redirection when
/// executing a command via the shell. This requires:
/// * cmd.exe (on Windows) or bash (on OSX / Linux) are in the path.
/// * Arguments containing whitespace are quoted.</param>
/// <returns>CommandLineTool result if successful, raises an exception if it's not
/// possible to execute the tool.</returns>
public static Result RunViaShell(
string toolPath, string arguments, string workingDirectory = null,
Dictionary <string, string> envVars = null,
IOHandler ioHandler = null, bool useShellExecution = false,
bool stdoutRedirectionInShellMode = true)
{
System.Text.Encoding inputEncoding = Console.InputEncoding;
System.Text.Encoding outputEncoding = Console.OutputEncoding;
Console.InputEncoding = System.Text.Encoding.UTF8;
Console.OutputEncoding = System.Text.Encoding.UTF8;
// Mono 3.x on Windows can't execute tools with single quotes (apostrophes) in the path.
// The following checks for this condition and forces shell execution of tools in these
// paths which works fine as the shell tool should be in the system PATH.
if (UnityEngine.RuntimePlatform.WindowsEditor == UnityEngine.Application.platform &&
toolPath.Contains("\'"))
{
useShellExecution = true;
stdoutRedirectionInShellMode = true;
}
string stdoutFileName = null;
string stderrFileName = null;
if (useShellExecution && stdoutRedirectionInShellMode)
{
stdoutFileName = Path.GetTempFileName();
stderrFileName = Path.GetTempFileName();
string shellCmd;
string shellArgPrefix;
string shellArgPostfix;
string escapedToolPath = toolPath;
if (UnityEngine.RuntimePlatform.WindowsEditor == UnityEngine.Application.platform)
{
shellCmd = "cmd.exe";
shellArgPrefix = "/c \"";
shellArgPostfix = "\"";
}
else
{
shellCmd = "bash";
shellArgPrefix = "-l -c '";
shellArgPostfix = "'";
escapedToolPath = toolPath.Replace("'", "'\\''");
}
arguments = String.Format("{0}\"{1}\" {2} 1> {3} 2> {4}{5}", shellArgPrefix,
escapedToolPath, arguments, stdoutFileName,
stderrFileName, shellArgPostfix);
toolPath = shellCmd;
}
Process process = new Process();
process.StartInfo.UseShellExecute = useShellExecution;
process.StartInfo.Arguments = arguments;
if (useShellExecution)
{
process.StartInfo.CreateNoWindow = false;
process.StartInfo.RedirectStandardOutput = false;
process.StartInfo.RedirectStandardError = false;
}
else
{
process.StartInfo.CreateNoWindow = true;
process.StartInfo.RedirectStandardOutput = true;
process.StartInfo.RedirectStandardError = true;
if (envVars != null)
{
foreach (var env in envVars)
{
process.StartInfo.EnvironmentVariables[env.Key] = env.Value;
}
}
}
process.StartInfo.RedirectStandardInput = !useShellExecution && (ioHandler != null);
process.StartInfo.FileName = toolPath;
process.StartInfo.WorkingDirectory = workingDirectory ?? Environment.CurrentDirectory;
process.Start();
// If an I/O handler was specified, call it with no data to provide a process and stdin
// handle before output data is sent to it.
if (ioHandler != null)
{
ioHandler(process, process.StandardInput, StreamData.Empty);
}
List <string>[] stdouterr = new List <string>[] {
new List <string>(), new List <string>()
};
if (useShellExecution)
{
process.WaitForExit();
if (stdoutRedirectionInShellMode)
{
stdouterr[0].Add(File.ReadAllText(stdoutFileName));
stdouterr[1].Add(File.ReadAllText(stderrFileName));
File.Delete(stdoutFileName);
File.Delete(stderrFileName);
}
}
else
{
AutoResetEvent complete = new AutoResetEvent(false);
// Read raw output from the process.
AsyncStreamReader[] readers = AsyncStreamReader.CreateFromStreams(
new Stream[] { process.StandardOutput.BaseStream,
process.StandardError.BaseStream }, 1);
new AsyncStreamReaderMultiplexer(
readers,
(StreamData data) => {
stdouterr[data.handle].Add(data.text);
if (ioHandler != null)
{
ioHandler(process, process.StandardInput, data);
}
},
complete: () => { complete.Set(); });
foreach (AsyncStreamReader reader in readers)
{
reader.Start();
}
process.WaitForExit();
// Wait for the reading threads to complete.
complete.WaitOne();
}
Result result = new Result();
result.stdout = String.Join("", stdouterr[0].ToArray());
result.stderr = String.Join("", stdouterr[1].ToArray());
result.exitCode = process.ExitCode;
result.message = FormatResultMessage(toolPath, arguments, result.stdout,
result.stderr, result.exitCode);
Console.InputEncoding = inputEncoding;
Console.OutputEncoding = outputEncoding;
return(result);
}
private void OpenConnection(Connection connection, string data, Action initializeCallback, Action<Exception> errorCallback)
{
// If we're reconnecting add /connect to the url
bool reconnect = initializeCallback == null;
var url = (reconnect ? connection.Url : connection.Url + "connect") + GetReceiveQueryString(connection, data);
Action<HttpWebRequest> prepareRequest = PrepareRequest(connection);
HttpHelper.GetAsync(url, request =>
{
prepareRequest(request);
request.Accept = "text/event-stream";
}).ContinueWith(task =>
{
if (task.IsFaulted)
{
var exception = task.Exception.GetBaseException();
if (!IsRequestAborted(exception) &&
Interlocked.CompareExchange(ref connection._initializedCalled, 0, 0) == 0)
{
if (errorCallback != null)
{
errorCallback(exception);
}
else
{
// Raise the error event if we failed to reconnect
connection.OnError(exception);
}
}
}
else
{
// Get the reseponse stream and read it for messages
var stream = task.Result.GetResponseStream();
var reader = new AsyncStreamReader(stream,
connection,
() =>
{
if (Interlocked.CompareExchange(ref connection._initializedCalled, 1, 0) == 0)
{
initializeCallback();
}
},
() =>
{
// Wait for a bit before reconnecting
Thread.Sleep(ReconnectDelay);
// Now attempt a reconnect
OpenConnection(connection, data, initializeCallback: null, errorCallback: null);
});
reader.StartReading();
// Set the reader for this connection
connection.Items[ReaderKey] = reader;
}
});
if (initializeCallback != null)
{
TaskAsyncHelper.Delay(ConnectionTimeout).Then(() =>
{
if (Interlocked.CompareExchange(ref connection._initializedCalled, 1, 0) == 0)
{
// Stop the connection
Stop(connection);
// Connection timeout occured
errorCallback(new TimeoutException());
}
});
}
}
/// <summary>
/// Execute a command line tool.
/// </summary>
/// <param name="toolPath">Tool to execute. On Windows, if the path to this tool contains
/// single quotes (apostrophes) the tool will be executed via the shell.</param>
/// <param name="arguments">String to pass to the tools' command line.</param>
/// <param name="workingDirectory">Directory to execute the tool from.</param>
/// <param name="envVars">Additional environment variables to set for the command.</param>
/// <param name="ioHandler">Allows a caller to provide interactive input and also handle
/// both output and error streams from a single delegate. NOTE: This is ignored if
/// shell execution is enabled.</param>
/// <param name="useShellExecution">Execute the command via the shell. This disables
/// I/O redirection and causes a window to be popped up when the command is executed.
/// This uses file redirection to retrieve the standard output stream.
/// </param>
/// <param name="stdoutRedirectionInShellMode">Enables stdout and stderr redirection when
/// executing a command via the shell. This requires:
/// * cmd.exe (on Windows) or bash (on OSX / Linux) are in the path.
/// * Arguments containing whitespace are quoted.</param>
/// <returns>CommandLineTool result if successful, raises an exception if it's not
/// possible to execute the tool.</returns>
public static Result RunViaShell(
string toolPath, string arguments, string workingDirectory = null,
Dictionary <string, string> envVars = null,
IOHandler ioHandler = null, bool useShellExecution = false,
bool stdoutRedirectionInShellMode = true)
{
bool consoleConfigurationWarning = false;
Encoding inputEncoding = Console.InputEncoding;
Encoding outputEncoding = Console.OutputEncoding;
// Android SDK manager requires the input encoding to be set to
// UFT8 to pipe data to the tool.
// Cocoapods requires the output encoding to be set to UTF8 to
// retrieve output.
try {
var utf8Type = Encoding.UTF8.GetType();
// Only compare the type of the encoding class since the configuration shouldn't
// matter.
if (inputEncoding.GetType() != utf8Type)
{
Console.InputEncoding = Encoding.UTF8;
}
if (outputEncoding.GetType() != utf8Type)
{
Console.OutputEncoding = Encoding.UTF8;
}
} catch (Exception e) {
if (!displayedConsoleConfigurationWarning)
{
UnityEngine.Debug.LogWarning(String.Format(
"Unable to set console input / output encoding from {0} & {1} to {2} " +
"(e.g en_US.UTF8-8). Some commands may fail. {3}",
inputEncoding, outputEncoding, Encoding.UTF8, e));
consoleConfigurationWarning = true;
}
}
// Mono 3.x on Windows can't execute tools with single quotes (apostrophes) in the path.
// The following checks for this condition and forces shell execution of tools in these
// paths which works fine as the shell tool should be in the system PATH.
if (UnityEngine.RuntimePlatform.WindowsEditor == UnityEngine.Application.platform &&
toolPath.Contains("\'"))
{
useShellExecution = true;
stdoutRedirectionInShellMode = true;
}
else if (!(toolPath.StartsWith("\"") || toolPath.StartsWith("'")))
{
// If the path isn't quoted normalize separators.
// Windows can't execute commands using POSIX paths.
toolPath = FileUtils.NormalizePathSeparators(toolPath);
}
string stdoutFileName = null;
string stderrFileName = null;
if (useShellExecution && stdoutRedirectionInShellMode)
{
stdoutFileName = Path.GetTempFileName();
stderrFileName = Path.GetTempFileName();
string shellCmd;
string shellArgPrefix;
string shellArgPostfix;
string escapedToolPath = toolPath;
if (UnityEngine.RuntimePlatform.WindowsEditor == UnityEngine.Application.platform)
{
shellCmd = "cmd.exe";
shellArgPrefix = "/c \"";
shellArgPostfix = "\"";
}
else
{
shellCmd = "bash";
shellArgPrefix = "-l -c '";
shellArgPostfix = "'";
escapedToolPath = toolPath.Replace("'", "'\\''");
}
arguments = String.Format("{0}\"{1}\" {2} 1> {3} 2> {4}{5}", shellArgPrefix,
escapedToolPath, arguments, stdoutFileName,
stderrFileName, shellArgPostfix);
toolPath = shellCmd;
}
Process process = new Process();
process.StartInfo.UseShellExecute = useShellExecution;
process.StartInfo.Arguments = arguments;
if (useShellExecution)
{
process.StartInfo.CreateNoWindow = false;
process.StartInfo.RedirectStandardOutput = false;
process.StartInfo.RedirectStandardError = false;
}
else
{
process.StartInfo.CreateNoWindow = true;
process.StartInfo.RedirectStandardOutput = true;
process.StartInfo.RedirectStandardError = true;
if (envVars != null)
{
foreach (var env in envVars)
{
process.StartInfo.EnvironmentVariables[env.Key] = env.Value;
}
}
}
process.StartInfo.RedirectStandardInput = !useShellExecution && (ioHandler != null);
process.StartInfo.FileName = toolPath;
process.StartInfo.WorkingDirectory = workingDirectory ?? Environment.CurrentDirectory;
process.Start();
// If an I/O handler was specified, call it with no data to provide a process and stdin
// handle before output data is sent to it.
if (ioHandler != null)
{
ioHandler(process, process.StandardInput, StreamData.Empty);
}
List <string>[] stdouterr = new List <string>[] {
new List <string>(), new List <string>()
};
if (useShellExecution)
{
process.WaitForExit();
if (stdoutRedirectionInShellMode)
{
stdouterr[0].Add(File.ReadAllText(stdoutFileName));
stdouterr[1].Add(File.ReadAllText(stderrFileName));
File.Delete(stdoutFileName);
File.Delete(stderrFileName);
}
}
else
{
AutoResetEvent complete = new AutoResetEvent(false);
// Read raw output from the process.
AsyncStreamReader[] readers = AsyncStreamReader.CreateFromStreams(
new Stream[] { process.StandardOutput.BaseStream,
process.StandardError.BaseStream }, 1);
new AsyncStreamReaderMultiplexer(
readers,
(StreamData data) => {
stdouterr[data.handle].Add(data.text);
if (ioHandler != null)
{
ioHandler(process, process.StandardInput, data);
}
},
complete: () => { complete.Set(); });
foreach (AsyncStreamReader reader in readers)
{
reader.Start();
}
process.WaitForExit();
// Wait for the reading threads to complete.
complete.WaitOne();
}
Result result = new Result();
result.stdout = String.Join("", stdouterr[0].ToArray());
result.stderr = String.Join("", stdouterr[1].ToArray());
result.exitCode = process.ExitCode;
result.message = FormatResultMessage(toolPath, arguments, result.stdout,
result.stderr, result.exitCode);
try {
if (Console.InputEncoding != inputEncoding)
{
Console.InputEncoding = inputEncoding;
}
if (Console.OutputEncoding != outputEncoding)
{
Console.OutputEncoding = outputEncoding;
}
} catch (Exception e) {
if (!displayedConsoleConfigurationWarning)
{
UnityEngine.Debug.LogWarning(String.Format(
"Unable to restore console input / output encoding to {0} & {1}. {2}",
inputEncoding, outputEncoding, e));
consoleConfigurationWarning = true;
}
}
if (consoleConfigurationWarning)
{
displayedConsoleConfigurationWarning = true;
}
return(result);
}
private void OpenConnection(IConnection connection, string data, bool reconnecting)
{
// If we're reconnecting add /connect to the url
var url = reconnecting
? connection.Url
: connection.Url + "connect";
url += GetReceiveQueryStringWithGroups(connection, data);
Debug.WriteLine(string.Format("SSE: GET {0}", url));
HttpClient.Get(url, request =>
{
connection.PrepareRequest(request);
request.Accept = "text/event-stream";
}, true)
.ContinueWith(task =>
{
var response = task.Result;
if (response.Exception != null)
{
var exception = response.Exception.GetBaseException();
if (!IsRequestAborted(exception))
{
if (reconnecting)
{
// Only raise the error event if we failed to reconnect
connection.OnError(exception);
}
}
if (reconnecting)
{
// Retry
Reconnect(connection, data);
}
}
else
{
// Get the response stream and read it for messages
var stream = response.GetResponseStream();
var reader = new AsyncStreamReader(stream, connection, () =>
{
response.Close();
Reconnect(connection, data);
});
if (reconnecting)
// Raise the reconnect event if the connection comes back up
connection.OnReconnected();
reader.StartReading();
// Set the reader for this connection
connection.Items[ReaderKey] = reader;
}
});
}
/// <summary>
/// Execute a command line tool.
/// </summary>
/// <param name="toolPath">Tool to execute.</param>
/// <param name="arguments">String to pass to the tools' command line.</param>
/// <param name="workingDirectory">Directory to execute the tool from.</param>
/// <param name="envVars">Additional environment variables to set for the command.</param>
/// <param name="ioHandler">Allows a caller to provide interactive input and also handle
/// both output and error streams from a single delegate.</param>
/// <returns>CommandLineTool result if successful, raises an exception if it's not
/// possible to execute the tool.</returns>
public static Result Run(string toolPath, string arguments, string workingDirectory = null,
Dictionary <string, string> envVars = null,
IOHandler ioHandler = null)
{
System.Text.Encoding inputEncoding = Console.InputEncoding;
System.Text.Encoding outputEncoding = Console.OutputEncoding;
Console.InputEncoding = System.Text.Encoding.UTF8;
Console.OutputEncoding = System.Text.Encoding.UTF8;
Process process = new Process();
process.StartInfo.UseShellExecute = false;
process.StartInfo.Arguments = arguments;
process.StartInfo.CreateNoWindow = true;
process.StartInfo.RedirectStandardOutput = true;
process.StartInfo.RedirectStandardError = true;
if (envVars != null)
{
foreach (var env in envVars)
{
process.StartInfo.EnvironmentVariables[env.Key] = env.Value;
}
}
process.StartInfo.RedirectStandardInput = (ioHandler != null);
process.StartInfo.FileName = toolPath;
process.StartInfo.WorkingDirectory = workingDirectory ?? Environment.CurrentDirectory;
process.Start();
// If an I/O handler was specified, call it with no data to provide a process and stdin
// handle before output data is sent to it.
if (ioHandler != null)
{
ioHandler(process, process.StandardInput, StreamData.Empty);
}
AutoResetEvent complete = new AutoResetEvent(false);
List <string>[] stdouterr = new List <string>[] { new List <string>(),
new List <string>() };
// Read raw output from the process.
AsyncStreamReader[] readers = AsyncStreamReader.CreateFromStreams(
new Stream[] { process.StandardOutput.BaseStream,
process.StandardError.BaseStream }, 1);
new AsyncStreamReaderMultiplexer(
readers,
(StreamData data) => {
stdouterr[data.handle].Add(data.text);
if (ioHandler != null)
{
ioHandler(process, process.StandardInput, data);
}
},
complete: () => { complete.Set(); });
foreach (AsyncStreamReader reader in readers)
{
reader.Start();
}
process.WaitForExit();
// Wait for the reading threads to complete.
complete.WaitOne();
Result result = new Result();
result.stdout = String.Join("", stdouterr[0].ToArray());
result.stderr = String.Join("", stdouterr[1].ToArray());
result.exitCode = process.ExitCode;
Console.InputEncoding = inputEncoding;
Console.OutputEncoding = outputEncoding;
return(result);
}
private static ProcessReturn ExecuteCommand(string args, string dir = "", string exe = "git.exe")
{
string appPath = Path.GetDirectoryName(Application.ExecutablePath);
exe = Util.PathCombine(appPath, "Libraries", "git", "bin", exe);
var startInfo = new ProcessStartInfo {
FileName = exe,
Arguments = args,
CreateNoWindow = true,
RedirectStandardError = true,
RedirectStandardOutput = true,
UseShellExecute = false,
WorkingDirectory = dir
};
startInfo.EnvironmentVariables["HOME"] = Util.PathCombine(GetAppDataPath(), RestClient.Username);
for (int i = 0; i < 3; i++) {
var process = new Process {StartInfo = startInfo};
process.Start();
AsyncStreamReader stdout = new AsyncStreamReader(process.StandardOutput.BaseStream),
stderr = new AsyncStreamReader(process.StandardError.BaseStream);
if (!process.WaitForExit(ProcessTimeout)) {
return new ProcessReturn(-1, "", "Process timed out.");
}
string stdoutStr = stdout.GetData(), stderrStr = stderr.GetData();
// Retry if the lock is in use.
if (i == 2 || !stderrStr.Contains("index.lock")) {
return new ProcessReturn(process.ExitCode, stdoutStr, stderrStr);
}
Thread.Sleep(100);
}
// should never actually happen
return new ProcessReturn(-1, "", "");
}
static void Main(string[] args)
{
Console.WriteLine("FortniteLauncher made by ElLondiuh");
if (!File.Exists(launcherExe) | !File.Exists(shippingExe) | !File.Exists(eacShippingExe))
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("[ERROR] Something is wrong with your Fortnite installation or can't find your installation");
Thread.Sleep(3000);
Environment.Exit(2);
}
Console.WriteLine("Do you want to authenticate? Y | N");
if (Console.ReadKey().Key == ConsoleKey.Y)
{
Console.WriteLine("Authorization requiered:");
token = Auth.GetToken(Console.ReadLine());
exchange = Auth.GetExchange(token);
authType = "exchangecode";
}
//You don't really need to use the args for the launcher and the eac shipping but the EGL does that
var launchArgs = $"-obfuscationid={obfuscationid} -AUTH_LOGIN=unused -AUTH_PASSWORD={exchange} -AUTH_TYPE={authType} -epicapp=Fortnite -epicenv=Prod -EpicPortal -noeac -nobe -fltoken=fdd9g715h4i20110dd40d7d3";
// I launch FortniteLauncher and FortniteClient-Win64-Shipping_EAC and freeze them to bypass the protection
_fnLauncher = new Process
{
StartInfo =
{
FileName = launcherExe,
Arguments = launchArgs
}
};
_fnLauncher.Start();
foreach (ProcessThread thread in _fnLauncher.Threads)
{
Win32.SuspendThread(Win32.OpenThread(0x0002, false, thread.Id));
}
_fnEacProcess = new Process
{
StartInfo =
{
FileName = eacShippingExe,
Arguments = launchArgs
}
};
_fnEacProcess.Start();
foreach (ProcessThread thread in _fnEacProcess.Threads)
{
Win32.SuspendThread(Win32.OpenThread(0x0002, false, thread.Id));
}
//AsyncStreamReaders and RedirectStandardOutput to have fortnite output in the console
_fnProcess = new Process
{
StartInfo =
{
FileName = shippingExe,
Arguments = launchArgs,
UseShellExecute = false,
RedirectStandardOutput = true
}
};
_fnProcess.Start();
AsyncStreamReader asyncOutputReader = new AsyncStreamReader(_fnProcess.StandardOutput);
asyncOutputReader.DataReceived += delegate(object sender, string data)
{
Console.WriteLine(data);
};
asyncOutputReader.Start();
Injector.InjectDll(_fnProcess.Id, sslBypassDLL);
//If the game is closed kill the launcher and the eac shipping
_fnProcess.WaitForExit();
_fnLauncher.Kill();
_fnEacProcess.Kill();
}
public void Start()
{
if (IsRunning)
throw new ApplicationException("already running.");
_wasClosed = false;
_process = new Process();
_process.StartInfo.FileName = this.AppFileName;
if (Arguments != null)
_process.StartInfo.Arguments = Arguments;
if (WorkingDirectory != null)
_process.StartInfo.WorkingDirectory = WorkingDirectory;
_process.StartInfo.RedirectStandardInput = true;
_process.StartInfo.RedirectStandardOutput = ModeStdout != CommunicationMode.None;
_process.StartInfo.RedirectStandardError = ModeStderr != CommunicationMode.None;
_process.StartInfo.UseShellExecute = false;
_process.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
_process.StartInfo.CreateNoWindow = true;
if (ModeStderr == CommunicationMode.None && ModeStdout == CommunicationMode.None)
{
_process.Exited += _process_Exited;
_process.EnableRaisingEvents = true;
}
_process.Start();
ProcessId = _process.Id;
try { _process.PriorityClass = PriorityClass; }
catch
{
}
// Stderr
if (ModeStderr != CommunicationMode.None)
{
_stderrReader = new AsyncStreamReader(_process.StandardError.BaseStream, BufferSizeStderr);
_stderrReader.DataRead += _stderrReader_DataRead;
}
if (ModeStderr == CommunicationMode.Line)
{
_stderrLineReader = new AsyncLineReader(_stderrReader);
if (Encoding != null) _stderrLineReader.Encoding = Encoding;
_stderrLineReader.LineRead += _stderrLineReader_LineRead;
}
// Stdout
if (ModeStdout != CommunicationMode.None)
{
_stdoutReader = new AsyncStreamReader(_process.StandardOutput.BaseStream, BufferSizeStdout);
_stdoutReader.DataRead += _stdoutReader_DataRead;
}
if (ModeStdout == CommunicationMode.Line)
{
_stdoutLineReader = new AsyncLineReader(_stdoutReader);
if (Encoding != null) _stdoutLineReader.Encoding = Encoding;
_stdoutLineReader.LineRead += _stdoutLineReader_LineRead;
}
if (ModeStderr != CommunicationMode.None)
_stderrReader.Begin();
if (ModeStdout != CommunicationMode.None)
_stdoutReader.Begin();
}
private void materialRaisedButtonLaunch_Click(object sender, EventArgs e)
{
#if ONLINE
if (CheckUpdates("Launch"))
{
// Check if we previously showed that we required an update.
if (!_showedUpdate)
{
var result = MessageBox.Show("You must update Aurora Launcher to launch Fortnite.", string.Empty,
MessageBoxButtons.OKCancel);
if (result == DialogResult.Cancel)
{
_showedUpdate = true;
return;
}
}
Process.Start(Build.LauncherUri);
return;
}
#endif
if (string.IsNullOrEmpty(materialSingleLineTextFieldEmail.Text) || materialSingleLineTextFieldEmail.Text.Length < 3)
{
MessageBox.Show("Email cannot be empty or below 3 characters.", string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
if (!IsValidEmail(materialSingleLineTextFieldEmail.Text))
{
MessageBox.Show("Invalid Email, are you sure it's correct?", string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
if (string.IsNullOrEmpty(materialSingleLineTextFieldPassword.Text) || materialSingleLineTextFieldPassword.Text.Length < 3)
{
MessageBox.Show("Password cannot be empty or below 3 characters.", string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
// TODO: Fix this?
if (materialSingleLineTextFieldPassword.Text.Contains(" "))
{
MessageBox.Show("Invalid Password, are you sure it's correct?", string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
// Sigh...
try
{
if (!IsValidPath(Configuration.InstallLocation))
{
MessageBox.Show("Invalid installation path.", string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
}
catch
{
MessageBox.Show("Invalid installation path.", string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
var clientPath = Path.Combine(Configuration.InstallLocation, $"FortniteGame\\Binaries\\Win64\\{Build.ClientExecutable}");
if (!File.Exists(clientPath))
{
var text =
$"\"{clientPath}\" was not found, please make sure it exists." + "\n\n" +
"Did you set the Install Location correctly?" + "\n\n" +
"TIP: The Install Location must be set to a folder that contains 2 folders named \"Engine\" and \"FortniteGame\".";
MessageBox.Show(text, string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
var nativePath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), Build.LauncherNative);
if (!File.Exists(nativePath))
{
var text =
$"\"{nativePath}\" was not found, please make sure it exists." + "\n\n" +
"Did you extract all files from the ZIP when you downloaded Aurora Launcher?" + "\n\n" +
$"TIP: \"{Build.LauncherNative}\" must be in the same directory as Aurora Launcher.";
MessageBox.Show(text, string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
var arguments = $"-AUTH_LOGIN={Configuration.Email} -AUTH_PASSWORD={Configuration.Password} -AUTH_TYPE=epic {Configuration.Arguments}";
if (_clientAnticheat == 0) // None
{
arguments += $" {Build.ClientArguments} -noeac -nobe -fltoken=none";
}
else if (_clientAnticheat == 1) // BattlEye
{
arguments += $" {Build.ClientArguments} -noeac -fromfl=be -fltoken={Build.BeToken}";
}
else if (_clientAnticheat == 2) // EasyAntiCheat
{
arguments += $" {Build.ClientArguments} -nobe -fromfl=eac -fltoken={Build.EacToken}";
}
_clientProcess = new Process
{
StartInfo = new ProcessStartInfo(clientPath, arguments)
{
UseShellExecute = false,
RedirectStandardOutput = true,
CreateNoWindow = false
}
};
_clientProcess.Start();
#if !NATIVE
// Allocate the console, for standard output.
Win32.AllocConsole();
// Setup an AsyncStreamReader, for standard output.
var reader = new AsyncStreamReader(_clientProcess.StandardOutput);
reader.ValueRecieved += delegate(object sender, string value)
{
Console.ForegroundColor = ConsoleColor.White;
Console.Write(value);
Console.ForegroundColor = ConsoleColor.Gray;
};
reader.Start();
#else
Helper.InjectDll(_clientProcess.Id, nativePath);
#endif // NATIVE
}
private void OpenConnection(IConnection connection,
string data,
Action initializeCallback,
Action<Exception> errorCallback)
{
// If we're reconnecting add /connect to the url
bool _reconnecting = initializeCallback == null;
string _url = (_reconnecting ? connection.Url : connection.Url + "connect");
Action<IRequest> _prepareRequest = PrepareRequest(connection);
EventSignal<IResponse> _signal;
if (shouldUsePost(connection))
{
_url += GetReceiveQueryString(connection, data);
Debug.WriteLine("ServerSentEventsTransport: POST {0}", _url);
_signal = m_httpClient.PostAsync(
_url,
request =>
{
_prepareRequest(request);
request.Accept = "text/event-stream";
},
new Dictionary<string, string> {
{
"groups", GetSerializedGroups(connection) }
});
}
else
{
_url += GetReceiveQueryStringWithGroups(connection, data);
Debug.WriteLine("ServerSentEventsTransport: GET {0}", _url);
_signal = m_httpClient.GetAsync(
_url,
request =>
{
_prepareRequest(request);
request.Accept = "text/event-stream";
});
}
_signal.Finished += (sender, e) =>
{
if (e.Result.IsFaulted)
{
Exception _exception = e.Result.Exception.GetBaseException();
if (!HttpBasedTransport.IsRequestAborted(_exception))
{
if (errorCallback != null &&
Interlocked.Exchange(ref m_initializedCalled, 1) == 0)
errorCallback(_exception);
else if (_reconnecting)
// Only raise the error event if we failed to reconnect
connection.OnError(_exception);
}
if (_reconnecting)
{
// Retry
Reconnect(connection, data);
return;
}
}
else
{
// Get the reseponse stream and read it for messages
IResponse _response = e.Result;
Stream _stream = _response.GetResponseStream();
AsyncStreamReader _reader = new AsyncStreamReader(
_stream,
connection,
() =>
{
if (Interlocked.CompareExchange(ref m_initializedCalled, 1, 0) == 0)
initializeCallback();
},
() =>
{
_response.Close();
Reconnect(connection, data);
});
if (_reconnecting)
// Raise the reconnect event if the connection comes back up
connection.OnReconnected();
_reader.StartReading();
// Set the reader for this connection
connection.Items[m_readerKey] = _reader;
}
};
if (initializeCallback != null)
{
int _tryed = 0;
while (true)
{
_tryed++;
Debug.WriteLine("Checking if connection initialized for the {0} time: ", _tryed.ToString());
Thread.Sleep(m_connectionTimeout);
if (Interlocked.CompareExchange(ref m_initializedCalled, 1, 0) == 0)
{
if (_tryed < m_connectionRetry)
{
Debug.WriteLine("Connection initialized failed after {0} times.", _tryed.ToString());
continue;
}
Debug.WriteLine("Giving up on connection initializing.");
// Stop the connection
Stop(connection);
// Connection timeout occurred
errorCallback(new TimeoutException());
break;
}
else
{
Debug.WriteLine("Connection initialized succeed.");
break;
}
}
}
}
static void Main(string[] args)
{
string joinedArgs = string.Join(" ", args);
// Check if -FORCECONSOLE exists in args (regardless of case) to force console (due to Epic Games Launcher by default hiding it)
if (joinedArgs.ToUpper().Contains("-FORCECONSOLE"))
{
joinedArgs = Regex.Replace(joinedArgs, "-FORCECONSOLE", string.Empty, RegexOptions.IgnoreCase);
new Process
{
StartInfo =
{
FileName = Path.GetFileName(Assembly.GetEntryAssembly().Location),
Arguments = joinedArgs,
UseShellExecute = false
}
}.Start();
Environment.Exit(0);
}
// Check if the Fortnite client exists in the current work path.
if (!File.Exists(FORTNITE_EXECUTABLE))
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine($"\"{FORTNITE_EXECUTABLE}\" is missing!");
Console.ReadKey();
Environment.Exit(1);
}
// Check if -NOSSLPINNING exists in args (regardless of case) to disable SSL pinning
if (joinedArgs.ToUpper().Contains("-NOSSLPINNING"))
{
joinedArgs = Regex.Replace(joinedArgs, "-NOSSLPINNING", string.Empty, RegexOptions.IgnoreCase);
Patcher.noSslPinning = true;
}
// Setup a process exit event handler
AppDomain.CurrentDomain.ProcessExit += new EventHandler(OnProcessExit);
// Initialize Fortnite process with start info
_fnProcess = new Process
{
StartInfo =
{
FileName = FORTNITE_EXECUTABLE,
Arguments = $"{joinedArgs} -noeac -nobe -fltoken=none",
RedirectStandardOutput = true,
RedirectStandardError = true,
UseShellExecute = false
}
};
_fnProcess.Start(); // Start Fortnite client process
// Set up our async readers
AsyncStreamReader asyncOutputReader = new AsyncStreamReader(_fnProcess.StandardOutput);
AsyncStreamReader asyncErrorReader = new AsyncStreamReader(_fnProcess.StandardError);
asyncOutputReader.DataReceived += delegate(object sender, string data)
{
Console.ForegroundColor = ConsoleColor.White;
string formattedData = data.ToUpper().Replace(" ", "_"); // Convert data to all uppercase characters and replace spaces with "_"
// Check if formatted data contains "ASYNC_LOADING_INITIALIZED", if so, initalize the patcher (because we have to wait for Fortnite to be fully loaded into memory)
if (formattedData.Contains("ASYNC_LOADING_INITIALIZED") && _fnPatcher == null)
{
_fnPatcher = new Patcher(_fnProcess);
}
// Check if formatted data contains "STARTING_UPDATE_CHECK", if so, run the patcher (because Fortnite internal AC sucks!)
if (formattedData.Contains("STARTING_UPDATE_CHECK") && _fnPatcher != null)
{
_fnPatcher.Run();
}
Console.WriteLine(data);
};
asyncErrorReader.DataReceived += delegate(object sender, string data)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(data);
};
// Start our async readers
asyncOutputReader.Start();
asyncErrorReader.Start();
_fnProcess.WaitForExit(); // We'll wait for the Fortnite process to exit, otherwise our launcher will just close instantly
}
/// <summary>
/// Constructor for a STOMP 1.2 frame reader.
/// </summary>
/// <param name="stream">The stream to read from.</param>
/// <param name="bufferCapacity">The read buffer size.</param>
public Stomp12FrameReader(Stream stream, int? bufferCapacity = null)
{
_reader = new AsyncStreamReader(stream, Encoding.UTF8, bufferCapacity);
_readerOwner = true;
}
private void OpenConnection(IConnection connection, string data, Action initializeCallback, Action<Exception> errorCallback)
{
// If we're reconnecting add /connect to the url
bool reconnecting = initializeCallback == null;
var url = (reconnecting ? connection.Url : connection.Url + "connect") + GetReceiveQueryString(connection, data);
Action<IRequest> prepareRequest = PrepareRequest(connection);
_httpClient.GetAsync(url, request =>
{
prepareRequest(request);
request.Accept = "text/event-stream";
}).ContinueWith(task =>
{
if (task.IsFaulted)
{
var exception = task.Exception.GetBaseException();
if (!IsRequestAborted(exception))
{
if (errorCallback != null &&
Interlocked.Exchange(ref _initializedCalled, 1) == 0)
{
errorCallback(exception);
}
else if (reconnecting)
{
// Only raise the error event if we failed to reconnect
connection.OnError(exception);
}
}
if (reconnecting)
{
// Retry
Reconnect(connection, data);
return;
}
}
else
{
// Get the reseponse stream and read it for messages
var response = task.Result;
var stream = response.GetResponseStream();
var reader = new AsyncStreamReader(stream,
connection,
() =>
{
if (Interlocked.CompareExchange(ref _initializedCalled, 1, 0) == 0)
{
initializeCallback();
}
},
() =>
{
response.Close();
Reconnect(connection, data);
});
if (reconnecting)
{
// Raise the reconnect event if the connection comes back up
connection.OnReconnected();
}
reader.StartReading();
// Set the reader for this connection
connection.Items[ReaderKey] = reader;
}
});
if (initializeCallback != null)
{
TaskAsyncHelper.Delay(ConnectionTimeout).Then(() =>
{
if (Interlocked.CompareExchange(ref _initializedCalled, 1, 0) == 0)
{
// Stop the connection
Stop(connection);
// Connection timeout occured
errorCallback(new TimeoutException());
}
});
}
}
private void OpenConnection(Connection connection, string data, Action initializeCallback, Action <Exception> errorCallback)
{
// If we're reconnecting add /connect to the url
bool reconnect = initializeCallback == null;
var url = (reconnect ? connection.Url : connection.Url + "connect") + GetReceiveQueryString(connection, data);
Action <HttpWebRequest> prepareRequest = PrepareRequest(connection);
HttpHelper.GetAsync(url, request =>
{
prepareRequest(request);
request.Accept = "text/event-stream";
}).ContinueWith(task =>
{
if (task.IsFaulted)
{
var exception = task.Exception.GetBaseException();
if (!IsRequestAborted(exception) &&
Interlocked.CompareExchange(ref connection._initializedCalled, 0, 0) == 0)
{
if (errorCallback != null)
{
errorCallback(exception);
}
else
{
// Raise the error event if we failed to reconnect
connection.OnError(exception);
}
}
}
else
{
// Get the reseponse stream and read it for messages
var stream = task.Result.GetResponseStream();
var reader = new AsyncStreamReader(stream,
connection,
() =>
{
if (Interlocked.CompareExchange(ref connection._initializedCalled, 1, 0) == 0)
{
initializeCallback();
}
},
() =>
{
// Wait for a bit before reconnecting
Thread.Sleep(ReconnectDelay);
// Now attempt a reconnect
OpenConnection(connection, data, initializeCallback: null, errorCallback: null);
});
reader.StartReading();
// Set the reader for this connection
connection.Items[ReaderKey] = reader;
}
});
if (initializeCallback != null)
{
TaskAsyncHelper.Delay(ConnectionTimeout).Then(() =>
{
if (Interlocked.CompareExchange(ref connection._initializedCalled, 1, 0) == 0)
{
// Stop the connection
Stop(connection);
// Connection timeout occured
errorCallback(new TimeoutException());
}
});
}
}
/// <summary>
/// Run Pscp synchronously
/// </summary>
/// <param name="result">Result object where results </param>
/// <param name="args">The args to send to pscp</param>
/// <param name="argsToLog">The args that are logged or can be returned in status messages</param>
/// <param name="inlineOutHandler">Inline handler for output</param>
/// <param name="inlineErrHandler">Inline handler for error</param>
/// <param name="successOutHandler">Handler for output of successful operation</param>
private void RunPscp(
PscpResult result,
string args,
string argsToLog,
Func <string, bool> inlineOutHandler,
Func <string, bool> inlineErrHandler,
Action <string[]> successOutHandler)
{
if (!File.Exists(this.Options.PscpLocation))
{
result.SetError(string.Format("Pscp missing, path={0}.", this.Options.PscpLocation), null);
}
else if (this.Session.Username == null)
{
result.SetError("UserName is null", null);
}
else if (this.Session.Host == null)
{
result.SetError("Host is null", null);
}
else if (this.Session.Port < 0)
{
result.SetError("Invalid port: " + this.Session.Port, null);
}
else
{
Process proc = NewProcess(this.Options.PscpLocation, args);
Timer timeoutTimer = null;
AsyncStreamReader outReader = null;
AsyncStreamReader errReader = null;
try
{
// Start pscp
Log.InfoFormat("Starting process: file={0}, args={1}", this.Options.PscpLocation, argsToLog);
proc.Start();
// Timeout when no output is received
timeoutTimer = new Timer(
(x) =>
{
// timeout
SafeKill(proc);
result.SetErrorFormat("Process timed out, args={0}", argsToLog);
},
null, this.Options.TimeoutMs, Timeout.Infinite);
// Async read output/err. Inline actions to quick kill the process when pscp prompts user.
// NOTE: Using BeginReadOutput/ErrorReadLine doesn't work here. Calls to read an empty stream
// will block (e.g. "user's password:"******"OUT",
proc.StandardOutput,
strOut =>
{
bool keepReading = true;
bool completed = false;
if (strOut == PUTTY_INTERACTIVE_AUTH || strOut.Contains("assword:"))
{
result.StatusCode = ResultStatusCode.RetryAuthentication;
Log.Debug("Username/Password invalid or not sent");
SafeKill(proc);
keepReading = false;
}
else if (inlineOutHandler != null)
{
completed = inlineOutHandler(strOut);
}
timeoutTimer.Change(completed ? Timeout.Infinite : this.Options.TimeoutMs, Timeout.Infinite);
return(keepReading);
});
errReader = new AsyncStreamReader(
"ERR",
proc.StandardError,
strErr =>
{
bool keepReading = true;
bool completed = false;
if (strErr != null && strErr.Contains(PUTTY_NO_KEY))
{
result.SetError("Host key not cached. Connect via putty to cache key then try again", null);
SafeKill(proc);
keepReading = false;
}
else if (inlineErrHandler != null)
{
completed = inlineErrHandler(strErr);
}
timeoutTimer.Change(completed ? Timeout.Infinite : this.Options.TimeoutMs, Timeout.Infinite);
return(keepReading);
});
// start process and wait for results
Log.DebugFormat("WaitingForExit");
proc.WaitForExit();
Log.InfoFormat("Process exited, pid={0}, exitCode={1}", proc.Id, proc.ExitCode);
timeoutTimer.Change(Timeout.Infinite, Timeout.Infinite);
string[] output = outReader.StopAndGetData();
string[] err = errReader.StopAndGetData();
string outputStr = String.Join("\r\n", output);
if (proc.ExitCode == 0 && outputStr.Contains(PUTTY_UNABLE_TO_OPEN))
{
// bad path
int idx = outputStr.IndexOf(PUTTY_UNABLE_TO_OPEN);
result.SetErrorFormat(outputStr.Substring(idx));
}
else if (proc.ExitCode == 0)
{
// successful operation
if (successOutHandler != null)
{
successOutHandler(output);
}
}
else
{
// some kind of error
if (result.StatusCode != ResultStatusCode.Success)
{
Log.Debug("Skipping output check since proactively killed process.");
}
else if (output.Contains(PUTTY_ARGUMENTS_HELP_HEADER))
{
result.SetErrorFormat("Invalid arguments sent to pscp, args={0}, output={1}", args, output);
}
else if (err.Contains(PUTTY_HOST_DOES_NOT_EXIST))
{
result.SetErrorFormat("Host does not exist. {0}:{1}", this.Session.Host, this.Session.Port);
}
else
{
result.SetErrorFormat("Unknown error. exitCode={0}, out='{1}', err='{2}'", proc.ExitCode, String.Join("|", output), String.Join("|", err));
}
}
}
finally
{
SafeKill(proc);
SafeDispose(timeoutTimer, proc, outReader, errReader);
}
}
}
internal Stomp12FrameReader(AsyncStreamReader reader)
{
_reader = reader;
_readerOwner = false;
}
public static RunOutput RunAndGetOutput([NotNull] string execName, string arguments, RunSettingsBase settings, WaitHandle awaitableHandle)
{
settings ??= RunSettingsBase.Default;
settings.RedirectOutput = true;
settings.RedirectError = true;
RunOutput output = new RunOutput();
using (Process process = CreateForRun(execName, arguments, settings))
{
bool processReallyExited = false;
process.Exited += (sender, _) =>
{
Process p = (Process)sender;
if (p.IsAssociated())
{
try
{
output.ExitTime = p.ExitTime;
output.ExitCode = p.ExitCode;
}
catch
{
// ignored
}
}
processReallyExited = true;
settings.OnExit?.Invoke(execName, output.ExitTime, output.ExitCode);
};
try
{
bool result = process.Start();
if (!result)
{
return(null);
}
if (!settings.JobHandle.IsInvalidHandle())
{
ProcessJob.AddProcess(settings.JobHandle, process);
}
output.StartTime = process.StartTime;
settings.OnStart?.Invoke(execName, output.StartTime);
AsyncStreamReader outputReader = new AsyncStreamReader(process, process.StandardOutput.BaseStream, data =>
{
if (data == null)
{
return;
}
output.Output.Append(data);
output.OutputBuilder.Append(data);
}, process.StandardOutput.CurrentEncoding);
outputReader.BeginRead();
AsyncStreamReader errorReader = new AsyncStreamReader(process, process.StandardError.BaseStream, data =>
{
if (data == null)
{
return;
}
output.Error.Append(data);
output.OutputBuilder.Append(data);
}, process.StandardOutput.CurrentEncoding);
errorReader.BeginRead();
if (!awaitableHandle.IsAwaitable())
{
process.WaitForExit();
return(output);
}
SafeWaitHandle waitHandle = null;
ManualResetEvent processFinishedEvent = null;
try
{
waitHandle = new SafeWaitHandle(process.Handle, false);
if (!waitHandle.IsAwaitable())
{
return(null);
}
processFinishedEvent = new ManualResetEvent(false)
{
SafeWaitHandle = waitHandle
};
if (!awaitableHandle.IsAwaitable())
{
return(null);
}
WaitHandle[] waitHandles =
{
processFinishedEvent,
awaitableHandle
};
int ndx = waitHandles.WaitAny();
if (ndx != 0)
{
return(null);
}
if (!processReallyExited && process.IsAwaitable())
{
if (!process.WaitForExit(TimeSpanHelper.HALF))
{
ndx = -1;
}
}
process.Die();
return(ndx != 0 ? null : output);
}
finally
{
processFinishedEvent?.Close();
ObjectHelper.Dispose(ref processFinishedEvent);
waitHandle?.Close();
ObjectHelper.Dispose(ref waitHandle);
}
}
catch (Win32Exception e)
{
throw new InvalidOperationException(e.CollectMessages(), e);
}
}
}
static void Main(string[] args)
{
var formattedArguments = string.Join(" ", args);
#if GUI
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Gui(formattedArguments));
#else
// Check if -FORCEBE exists in args (regardless of case) to force BattlEye.
if (formattedArguments.ToUpper().Contains("-FORCEBE"))
{
formattedArguments = Regex.Replace(formattedArguments, "-FORCEBE", string.Empty, RegexOptions.IgnoreCase);
_clientAnticheat = 1;
}
// Check if -FORCEEAC exists in args (regardless of case) to force EasyAntiCheat.
if (formattedArguments.ToUpper().Contains("-FORCEEAC"))
{
formattedArguments = Regex.Replace(formattedArguments, "-FORCEEAC", string.Empty, RegexOptions.IgnoreCase);
_clientAnticheat = 2;
}
if (_clientAnticheat == 0) // None
{
formattedArguments += $" {Build.ClientArguments} -noeac -nobe -fltoken=none";
}
else if (_clientAnticheat == 1) // BattlEye
{
formattedArguments += $" {Build.ClientArguments} -noeac -fromfl=be -fltoken={Build.BeToken}";
}
else if (_clientAnticheat == 2) // EasyAntiCheat
{
formattedArguments += $" {Build.ClientArguments} -nobe -fromfl=eac -fltoken={Build.EacToken}";
}
#if !NATIVE
Win32.AllocConsole();
#endif // NATIVE
// Check if the client exists in the current work path, if it doesn't, just exit.
if (!File.Exists(Build.ClientExecutable))
{
#if NATIVE
Win32.AllocConsole();
#endif // NATIVE
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine($"\"{Build.ClientExecutable}\" was not found, please make sure it exists.");
Console.ForegroundColor = ConsoleColor.Gray;
Console.ReadKey();
return;
}
#if NATIVE
// Check if the native exists in the current work path, if it doesn't, just exit.
if (!File.Exists(Build.ClientNative))
{
Win32.AllocConsole();
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine($"\"{Build.ClientNative}\" was not found, please make sure it exists.");
Console.ForegroundColor = ConsoleColor.Gray;
Console.ReadKey();
return;
}
#endif // NATIVE
#if !NATIVE
Console.ForegroundColor = ConsoleColor.Magenta;
Console.WriteLine("Aurora, made with <3 by Cyuubi and Slushia.");
Console.WriteLine("Discord: https://discord.gg/aurorafn\n");
Console.ForegroundColor = ConsoleColor.Gray;
#endif // NATIVE
_clientProcess = new Process
{
StartInfo = new ProcessStartInfo(Build.ClientExecutable, formattedArguments)
{
UseShellExecute = false,
RedirectStandardOutput = true,
CreateNoWindow = false
}
};
#if !NO_EGL
Swap(); // Swap the launcher, to prevent Fortnite from detecting it.
#endif // NO_EGL
_clientProcess.Start();
#if !NATIVE
// Setup a HandlerRoutine, for detecting when the console closes.
Win32.SetConsoleCtrlHandler(new Win32.HandlerRoutine(Routine), true);
// Setup an AsyncStreamReader, for standard output.
var reader = new AsyncStreamReader(_clientProcess.StandardOutput);
reader.ValueRecieved += delegate(object sender, string value)
{
Console.ForegroundColor = ConsoleColor.White;
Console.Write(value);
Console.ForegroundColor = ConsoleColor.Gray;
};
reader.Start();
#else
Helper.InjectDll(_clientProcess.Id, Build.ClientNative);
#endif // NATIVE
_clientProcess.WaitForExit(); // Wait for the client process to exit.
#if !NO_EGL
Swap(); // Before exiting... Swap the launcher, again.
#endif // NO_EGL
#endif // GUI
}
/// <summary>
/// Run Pscp synchronously
/// </summary>
/// <param name="result">Result object where results </param>
/// <param name="args">The args to send to pscp</param>
/// <param name="argsToLog">The args that are logged or can be returned in status messages</param>
/// <param name="inlineOutHandler">Inline handler for output</param>
/// <param name="inlineErrHandler">Inline handler for error</param>
/// <param name="successOutHandler">Handler for output of successful operation</param>
private void RunPscp(
PscpResult result,
string args,
string argsToLog,
Func <string, bool> inlineOutHandler,
Func <string, bool> inlineErrHandler,
Action <string[]> successOutHandler)
{
if (!File.Exists(Options.PscpLocation))
{
result.SetError(string.Format(LocalizedText.PscpClient_RunPscp_Pscp_missing, Options.PscpLocation), null);
}
else if (Session.Username == null)
{
result.SetError(LocalizedText.PscpClient_RunPscp_UserName_is_null, null);
}
else if (Session.Host == null)
{
result.SetError(LocalizedText.PscpClient_RunPscp_Host_is_null, null);
}
else if (Session.Port < 0)
{
result.SetError(string.Format(LocalizedText.PscpClient_RunPscp_Invalid_port, Session.Port), null);
}
else
{
Process proc = NewProcess(Options.PscpLocation, args);
Timer timeoutTimer = null;
AsyncStreamReader outReader = null;
AsyncStreamReader errReader = null;
try
{
// Start pscp
Log.InfoFormat("Starting process: file={0}, args={1}", Options.PscpLocation, argsToLog);
proc.Start();
// Timeout when no output is received
timeoutTimer = new Timer(
(x) =>
{
// timeout
SafeKill(proc);
result.SetErrorFormat(LocalizedText.PscpClient_RunPscp_Process_timed_out, argsToLog);
},
null, Options.TimeoutMs, Timeout.Infinite);
// Async read output/err. Inline actions to quick kill the process when pscp prompts user.
// NOTE: Using BeginReadOutput/ErrorReadLine doesn't work here. Calls to read an empty stream
// will block (e.g. "user's password:"******"OUT",
proc.StandardOutput,
strOut =>
{
bool keepReading = true;
bool completed = false;
if (strOut == PuttyInteractiveAuth || strOut.Contains("assword:"))
{
result.StatusCode = ResultStatusCode.RetryAuthentication;
Log.Debug("Username/Password invalid or not sent");
SafeKill(proc);
keepReading = false;
}
else if (inlineOutHandler != null)
{
completed = inlineOutHandler(strOut);
}
timeoutTimer.Change(completed ? Timeout.Infinite : Options.TimeoutMs, Timeout.Infinite);
return(keepReading);
});
errReader = new AsyncStreamReader(
"ERR",
proc.StandardError,
strErr =>
{
bool keepReading = true;
bool completed = false;
if (strErr != null && strErr.Contains(PuttyNoKey))
{
result.SetError("Host key not cached. Connect via putty to cache key then try again", null);
SafeKill(proc);
keepReading = false;
}
else if (inlineErrHandler != null)
{
completed = inlineErrHandler(strErr);
}
timeoutTimer.Change(completed ? Timeout.Infinite : Options.TimeoutMs, Timeout.Infinite);
return(keepReading);
});
// start process and wait for results
Log.DebugFormat("WaitingForExit");
proc.WaitForExit();
Log.InfoFormat("Process exited, pid={0}, exitCode={1}", proc.Id, proc.ExitCode);
timeoutTimer.Change(Timeout.Infinite, Timeout.Infinite);
string[] output = outReader.StopAndGetData();
string[] err = errReader.StopAndGetData();
string outputStr = String.Join("\r\n", output);
if (proc.ExitCode == 0 && outputStr.Contains(PuttyUnableToOpen))
{
// bad path
int idx = outputStr.IndexOf(PuttyUnableToOpen, StringComparison.Ordinal);
result.SetErrorFormat(outputStr.Substring(idx));
}
else if (proc.ExitCode == 0)
{
// successful operation
successOutHandler?.Invoke(output);
}
else
{
// some kind of error
if (result.StatusCode != ResultStatusCode.Success)
{
Log.Debug("Skipping output check since proactively killed process.");
}
else if (output.Contains(PuttyArgumentsHelpHeader))
{
result.SetErrorFormat("Invalid arguments sent to pscp, args={0}, output={1}", args, output);
}
else if (err.Contains(PuttyHostDoesNotExist))
{
result.SetErrorFormat("Host does not exist. {0}:{1}", Session.Host, Session.Port);
}
else
{
result.SetErrorFormat("Unknown error. exitCode={0}, out='{1}', err='{2}'", proc.ExitCode, String.Join("|", output), String.Join("|", err));
}
}
}
finally
{
SafeKill(proc);
SafeDispose(timeoutTimer, proc, outReader, errReader);
}
}
}
private void OpenConnection(IConnection connection, string data, dotnet2::System.Action initializeCallback, Action<Exception> errorCallback)
{
// If we're reconnecting add /connect to the url
bool reconnecting = initializeCallback == null;
var url = (reconnecting ? connection.Url : connection.Url + "connect");
Action<IRequest> prepareRequest = PrepareRequest(connection);
EventSignal<IResponse> signal;
if (shouldUsePost(connection))
{
url += GetReceiveQueryString(connection, data);
Debug.WriteLine(string.Format("SSE: POST {0}", url));
signal = _httpClient.PostAsync(url, request =>
{
prepareRequest(request);
request.Accept = "text/event-stream";
}, new Dictionary<string, string> {{"groups", GetSerializedGroups(connection)}});
}
else
{
url += GetReceiveQueryStringWithGroups(connection, data);
Debug.WriteLine(string.Format("SSE: GET {0}", url));
signal = _httpClient.GetAsync(url, request =>
{
prepareRequest(request);
request.Accept = "text/event-stream";
});
}
signal.Finished += (sender,e)=> {
if (e.Result.IsFaulted)
{
var exception = e.Result.Exception.GetBaseException();
if (!IsRequestAborted(exception))
{
if (errorCallback != null &&
Interlocked.Exchange(ref _initializedCalled, 1) == 0)
{
errorCallback(exception);
}
else if (reconnecting)
{
// Only raise the error event if we failed to reconnect
connection.OnError(exception);
}
}
if (reconnecting)
{
// Retry
Reconnect(connection, data);
return;
}
}
else
{
// Get the reseponse stream and read it for messages
var response = e.Result;
var stream = response.GetResponseStream();
var reader = new AsyncStreamReader(stream,
connection,
() =>
{
if (Interlocked.CompareExchange(ref _initializedCalled, 1, 0) == 0)
{
initializeCallback();
}
},
() =>
{
response.Close();
Reconnect(connection, data);
});
if (reconnecting)
{
// Raise the reconnect event if the connection comes back up
connection.OnReconnected();
}
reader.StartReading();
// Set the reader for this connection
connection.Items[ReaderKey] = reader;
}
};
if (initializeCallback != null)
{
Thread.Sleep(ConnectionTimeout);
if (Interlocked.CompareExchange(ref _initializedCalled, 1, 0) == 0)
{
// Stop the connection
Stop(connection);
// Connection timeout occured
errorCallback(new TimeoutException());
}
}
}
