//

// Subprocess.cs

//

// Author:

// Lluis Sanchez <llsan@microsoft.com>

//

// Copyright (c) 2020 Microsoft

//

// Permission is hereby granted, free of charge, to any person obtaining a copy

// of this software and associated documentation files (the "Software"), to deal

// in the Software without restriction, including without limitation the rights

// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

// copies of the Software, and to permit persons to whom the Software is

// furnished to do so, subject to the following conditions:

//

// The above copyright notice and this permission notice shall be included in

// all copies or substantial portions of the Software.

//

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

// THE SOFTWARE.

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.IO;

using System.Text;

using System.Threading;

using Mono.Debugger.Soft;

using Mono.Debugging.Backend;

using Mono.Debugging.Client;

using Mono.Debugging.Evaluation;

namespace Mono.Debugging.Soft

{

class Subprocess

{

const string ArgStartMarker = "_ARG_START_";

readonly SoftDebuggerSession softDebuggerSession;

ManualResetEvent launchingEvent = new ManualResetEvent (false);

ManualResetEvent startedEvent = new ManualResetEvent (false);

string arguments;

string exe;

int processId;

bool shutdown;

ProcessStartInfo debuggerStartInfo;

SoftDebuggerSession newSession;

public SoftDebuggerSession SubprocessSession => newSession;

public long ThreadId { get; private set; }

public Subprocess (long threadId, SoftDebuggerSession softDebuggerSession)

{

ThreadId = threadId;

this.softDebuggerSession = softDebuggerSession;

}

public static bool IsMonoLauncher (string filePath)

{

var exeName = Path.GetFileName (filePath);

return exeName == "mono" || exeName == "mono64";

}

public bool CreateSession (ValueReference startInfo, EvaluationOptions ops)

{

// Get the exe and arguments from the start info and store them

this.arguments = (string)startInfo.GetChild ("Arguments", ops).GetRawValue (ops);

this.exe = (string)startInfo.GetChild ("FileName", ops).GetRawValue (ops);

// Create the new session and custom start arguments.

// The actual arguments don't matter much since we'll use a custom launcher for the process.

newSession = new SoftDebuggerSession ();

var startArgs = new SoftDebuggerLaunchArgs (null, new Dictionary<string, string> ());

var dsi = new SoftDebuggerStartInfo (startArgs);

// A mono process can be launched either by providing "mono" as launcher and then the assembly name as argument,

// or by providing the assembly name directly as file to launch.

bool explicitMonoLaunch = IsMonoLauncher (exe);

if (explicitMonoLaunch) {

// Try to get the assembly name from the command line. The debug session uses what's provided

// in the Command property as process name. Without this, all mono processes launched in this

// way would show up as "mono" in the IDE.

var cmd = GetExeName (arguments);

if (cmd != null)

dsi.Command = cmd;

// The new session will add additional runtime arguments to the start info.

// We'll use the _ARG_START_ marker to know where those arguments end.

dsi.RuntimeArguments = ArgStartMarker;

} else {

dsi.Command = exe;

dsi.Arguments = arguments;

}

startArgs.CustomProcessLauncher = TargetProcessLauncher;

// Start the session. This will run asynchronously, and will at some point call the custom launcher specified just above.

newSession.Run (dsi, softDebuggerSession.Options);

// Wait for the session to ask for the process to be launched

launchingEvent.WaitOne ();

if (shutdown)

return false;

// The custom launcher will store the debugger agent configuration args in debuggerStartInfo.

// No the original startInfo object is patched to include the debugger agent args

if (explicitMonoLaunch) {

// Prepend the debugger args to the original arguments

int i = debuggerStartInfo.Arguments.IndexOf (ArgStartMarker);

var debuggerArgs = debuggerStartInfo.Arguments.Substring (0, i);

startInfo.GetChild ("Arguments", ops).SetRawValue (debuggerArgs + " " + arguments, ops);

} else {

startInfo.GetChild ("Arguments", ops).SetRawValue (debuggerStartInfo.Arguments, ops);

startInfo.GetChild ("FileName", ops).SetRawValue (debuggerStartInfo.FileName, ops);

}

return true;

}

Process TargetProcessLauncher (ProcessStartInfo info)

{

// This callback is called by the debug session to start the process.

// We won't actually launch the process here since the current process is already doing it,

// we just need to wait for the process to be launched by resuming execution, and then return

// a reference to that process.

// Store a reference to the start info provided to start the process. We need to retrieve the

// debug agent configuration arguments from it.

debuggerStartInfo = info;

info.RedirectStandardError = false;

info.RedirectStandardOutput = false;

// Signal that the session asked the process to be started (this will cause execution to be resumed,

// so the process will be launched)

launchingEvent.Set ();

// Wait for the process to start

startedEvent.WaitOne ();

// processId should be set now. We can now return the process that has launched.

var process = Process.GetProcessById (processId);

process.EnableRaisingEvents = true;

return process;

}

public void SetStarted (ValueReference startInfo, int id, EvaluationContext ctx)

{

// This is called after the process is launched.

// Store the process ID. It will be used by TargetProcessLauncher to get a reference to the process.

processId = id;

// Assign the original exe and arguments to the start info object

startInfo.GetChild ("Arguments", ctx.Options).SetRawValue (arguments, ctx.Options);

startInfo.GetChild ("FileName", ctx.Options).SetRawValue (exe, ctx.Options);

// Signal TargetProcessLauncher that the process has started and the process ID is available.

startedEvent.Set ();

}

public static string GetExeName (string monoCommandArgs)

{

foreach (var arg in GetArguments (monoCommandArgs)) {

if (arg.StartsWith ("--"))

continue;

var ext = Path.GetExtension (arg).ToLower ();

if ((ext == ".dll" || ext == ".exe") && File.Exists (arg))

return arg;

}

return null;

}

static IEnumerable<string> GetArguments (string monoCommandArgs)

{

bool inQuotes = false;

var currentString = new StringBuilder ();

for (int n = 0; n < monoCommandArgs.Length; n++) {

var c = monoCommandArgs[n];

if (c == '\\') {

if (n < monoCommandArgs.Length - 1 && (monoCommandArgs[n + 1] == '\\' || monoCommandArgs[n + 1] == '"')) {

currentString.Append (monoCommandArgs[n + 1]);

n++;

}

} else if (inQuotes) {

if (c == '"')

inQuotes = false;

else

currentString.Append (c);

} else if (c == '"') {

inQuotes = true;

} else if (char.IsWhiteSpace (c)) {

if (currentString.Length > 0) {

yield return currentString.ToString ();

currentString.Clear ();

}

} else

currentString.Append (c);

}

if (currentString.Length > 0)

yield return currentString.ToString ();

}

public void Shutdown ()

{

shutdown = true;

launchingEvent.Set ();

startedEvent.Set ();

}

}

}