public void GetElevationForTwoLocations()
{
// expectations
var expectedStatus = ServiceResponseStatus.Ok;
var expectedResultCount = 2;
var expectedElevation1 = 1608.8402100m;
var expectedLocationLatitude1 = 39.7391536m;
var expectedLocationLongitude1 = -104.9847034m;
var expectedElevation2 = -50.7890358m;
var expectedLocationLatitude2 = 36.4555560m;
var expectedLocationLongitude2 = -116.8666670m;
// test
var request = new ElevationRequest();
request.Locations = "39.7391536,-104.9847034|36.455556,-116.866667";
request.Sensor = "false";
var response = ElevationService.GetResponse(request);
// asserts
Assert.AreEqual(expectedStatus, response.Status);
Assert.AreEqual(expectedResultCount, response.Results.Length);
Assert.AreEqual(expectedElevation1, response.Results.First().Elevation);
Assert.AreEqual(expectedLocationLatitude1, response.Results.First().Location.Latitude);
Assert.AreEqual(expectedLocationLongitude1, response.Results.First().Location.Longitude);
Assert.AreEqual(expectedElevation2, response.Results.Last().Elevation);
Assert.AreEqual(expectedLocationLatitude2, response.Results.Last().Location.Latitude);
Assert.AreEqual(expectedLocationLongitude2, response.Results.Last().Location.Longitude);
}
public static double GetAltitudeWithKEY(double lat, double lng, string key)
{
var elevationRequest = new ElevationRequest {
Locations = new[] { new Location(lat, lng) },
};
elevationRequest.ApiKey = key;
try {
ElevationResponse elevation = GoogleMaps.Elevation.Query(elevationRequest);
if (elevation.Status == Status.OK)
{
foreach (Result result in elevation.Results)
{
return(result.Elevation);
}
}
} catch (Exception ex1) {
Logger.ExceptionInfo(ex1.ToString());
}
return(GetRandom(11.0d, 8.6d));
}
/// <summary>
/// Get an elevation request in real world coordinates for a vertex number in tile
/// </summary>
/// <param name="vertexNumber">Vertex number of the tile</param>
/// <returns>An elevation request with real world coordinates from vertex number</returns>
public ElevationRequest GetPointsLocations(int vertexNumber)
{
var request = new ElevationRequest();
var southWest = GetSouthWest();
var northEast = GetNorthEast();
double tileWidth = Math.Sqrt(vertexNumber);
double latDistanceBetweenPoints = Math.Abs(Math.Abs(northEast.Lat) - Math.Abs(southWest.Lat)) / (tileWidth - 1);
double lngDistanceBetweenPoints = Math.Abs(Math.Abs(northEast.Lon) - Math.Abs(southWest.Lon)) / (tileWidth - 1);
for (int i = 0; i < vertexNumber; i++)
{
var lat = GetLatFromSouthWest(i, tileWidth, latDistanceBetweenPoints, southWest);
var lng = GetLngFromSouthWest(i, tileWidth, lngDistanceBetweenPoints, southWest);
Location vertexC = new Location();
vertexC.latitude = (float)lat;
vertexC.longitude = (float)lng;
request.locations.Add(vertexC);
}
return(request);
}
public async Task Start(Connection connection, ElevationRequest request)
{
try
{
int exitCode = 0;
process = ProcessFactory.StartDetached(request.FileName, request.Arguments, request.StartFolder, false);
// Windows allows us to SetFocus on the new window if only if
// this gsudo (service) has the focus. So we request the gsudo client to set focus as well.
await connection.ControlStream
.WriteAsync($"{Constants.TOKEN_FOCUS}{process.MainWindowHandle}{Constants.TOKEN_FOCUS}")
.ConfigureAwait(false);
if (request.Wait)
{
process.WaitForExit();
exitCode = process.ExitCode;
}
await connection.ControlStream
.WriteAsync($"{Constants.TOKEN_EXITCODE}{exitCode}{Constants.TOKEN_EXITCODE}")
.ConfigureAwait(false);
await connection.FlushAndCloseAll().ConfigureAwait(false);
return;
}
catch (Exception ex)
{
Logger.Instance.Log(ex.ToString(), LogLevel.Error);
if (connection.IsAlive)
{
await connection.ControlStream.WriteAsync($"{Constants.TOKEN_ERROR}Server Error: {ex.ToString()}\r\n{Constants.TOKEN_ERROR}").ConfigureAwait(false);
}
await connection.FlushAndCloseAll().ConfigureAwait(false);
return;
}
}
private static IProcessRenderer GetRenderer(Connection connection, ElevationRequest elevationRequest)
{
if (elevationRequest.Mode == ElevationRequest.ConsoleMode.TokenSwitch)
{
try
{
return new TokenSwitchRenderer(connection, elevationRequest);
}
catch (Exception ex)
{
Logger.Instance.Log($"TokenSwitchRenderer mode failed with {ex.ToString()}. Fallback to Attached Mode", LogLevel.Debug);
elevationRequest.Mode = ElevationRequest.ConsoleMode.Attached; // fallback to attached mode.
return new AttachedConsoleRenderer(connection);
}
}
if (elevationRequest.Mode == ElevationRequest.ConsoleMode.Attached)
return new AttachedConsoleRenderer(connection);
if (elevationRequest.Mode == ElevationRequest.ConsoleMode.Piped)
return new PipedClientRenderer(connection);
else
return new VTClientRenderer(connection, elevationRequest);
}
public void GetElevationForOneLocation()
{
// expectations
var expectedStatus = ServiceResponseStatus.Ok;
var expectedResultCount = 1;
var expectedElevation = 1608.8402100m;
var expectedLocationLatitude = 39.7391536m;
var expectedLocationLongitude = -104.9847034m;
// test
var request = new ElevationRequest();
request.Locations = "39.7391536,-104.9847034";
request.Sensor = "false";
var response = ElevationService.GetResponse(request);
// asserts
Assert.AreEqual(expectedStatus, response.Status);
Assert.AreEqual(expectedResultCount, response.Results.Length);
Assert.AreEqual(expectedElevation, response.Results.Single().Elevation);
Assert.AreEqual(expectedLocationLatitude, response.Results.Single().Location.Latitude);
Assert.AreEqual(expectedLocationLongitude, response.Results.Single().Location.Longitude);
}
public void GetQueryStringParametersWhenChannelTest()
{
var request = new ElevationRequest
{
Key = "key",
Locations = new[]
{
new Coordinate(1, 1)
},
Channel = "channel"
};
var queryStringParameters = request.GetQueryStringParameters();
Assert.IsNotNull(queryStringParameters);
var channel = queryStringParameters.FirstOrDefault(x => x.Key == "channel");
var channelExpected = request.Channel;
Assert.IsNotNull(channel);
Assert.AreEqual(channelExpected, channel.Value);
}
public void GetQueryStringParametersWhenLocationsWhenMultipleCoordinatesTest()
{
var request = new ElevationRequest
{
Key = "key",
Locations = new[]
{
new Coordinate(1, 1),
new Coordinate(2, 2)
}
};
var queryStringParameters = request.GetQueryStringParameters();
Assert.IsNotNull(queryStringParameters);
var locations = queryStringParameters.FirstOrDefault(x => x.Key == "locations");
var locationsExpected = string.Join("|", request.Locations);
Assert.IsNotNull(locations);
Assert.AreEqual(locationsExpected, locations.Value);
}
public static void ReplaceProcessToken(ElevationRequest elevationRequest)
{
SafeTokenHandle desiredToken;
desiredToken = GetDesiredToken(elevationRequest);
try
{
var tokenInfo = new NtDllApi.PROCESS_ACCESS_TOKEN();
tokenInfo.Token = desiredToken.DangerousGetHandle();
tokenInfo.Thread = IntPtr.Zero;
TokenProvider
.CreateFromSystemAccount()
.EnablePrivilege(Privilege.SeAssignPrimaryTokenPrivilege, true)
.Impersonate(() =>
{
IntPtr hProcess = ProcessApi.OpenProcess(ProcessApi.PROCESS_SET_INFORMATION, true,
(uint)elevationRequest.TargetProcessId);
NtDllApi.PROCESS_INFORMATION_CLASS processInformationClass =
NtDllApi.PROCESS_INFORMATION_CLASS.ProcessAccessToken;
int res = NtDllApi.NativeMethods.NtSetInformationProcess(hProcess, processInformationClass,
ref tokenInfo,
Marshal.SizeOf <NtDllApi.PROCESS_ACCESS_TOKEN>());
Logger.Instance.Log($"NtSetInformationProcess returned {res}", LogLevel.Debug);
if (res < 0)
{
throw new Win32Exception();
}
ProcessApi.CloseHandle(hProcess);
});
}
finally
{
desiredToken?.Close();
}
}
public void UpdateElevations()
{
if (!chkStopUpdate.Checked)
{
int TakeAmt = 50;
ElevationRequest eReq = new ElevationRequest()
{
Locations = SimpleGPSs.Where(s => s.Elevation == -1).OrderBy(s => s.X).OrderBy(s => s.Y).Take(TakeAmt).Select(s => s.ToLocation()).ToList <Location>()
};
var result = GoogleMaps.Elevation.Query(eReq);
if (result.Status == GoogleMapsApi.Entities.Elevation.Response.Status.OVER_QUERY_LIMIT)
{
Console.WriteLine("Elevation Request Query Limit Exceeded");
SaveFile();
}
else
{
Populate(result.Results);
if (SimpleGPSs.Where(s => s.Elevation == -1).Count() > 0)
{
//Console.WriteLine(SimpleGPSs.Where(s => s.Elevation == -1).Count() + " OF " + SimpleGPSs.Count() + " have been mapped.");
UpdateElevations();
}
else
{
this.ManageStopFlag("Update Completed...");
}
}
}
else
{
this.ManageStopFlag("User Stopped Updating - Begin Save()...");
}
}
public void GetElevationForOneLocation()
{
// expectations
var expectedStatus = ServiceResponseStatus.Ok;
var expectedResultCount = 1;
var expectedElevation = 1608.6m;
var expectedLocation = new LatLng(39.739153, -104.984703);
// test
var request = new ElevationRequest();
request.AddLocations(expectedLocation);
request.Sensor = false;
var response = new ElevationService().GetResponse(request);
// asserts
Assert.AreEqual(expectedStatus, response.Status);
Assert.AreEqual(expectedResultCount, response.Results.Length);
Assert.That(expectedElevation, Is.EqualTo(response.Results[0].Elevation).Within(0.1));
Assert.That(expectedLocation, Is.EqualTo(response.Results[0].Location));
}
public void GetElevationForOneLocation()
{
// expectations
var expectedStatus = ServiceResponseStatus.Ok;
var expectedResultCount = 1;
var expectedElevation = 1608.8402100m;
var expectedLocationLatitude = 39.7391536m;
var expectedLocationLongitude = -104.9847034m;
// test
var request = new ElevationRequest();
request.Locations = "39.7391536,-104.9847034";
request.Sensor = "false";
var response = ElevationService.GetResponse(request);
// asserts
Assert.AreEqual(expectedStatus, response.Status);
Assert.AreEqual(expectedResultCount, response.Results.Length);
Assert.AreEqual(expectedElevation, response.Results.Single().Elevation);
Assert.AreEqual(expectedLocationLatitude, response.Results.Single().Location.Latitude);
Assert.AreEqual(expectedLocationLongitude, response.Results.Single().Location.Longitude);
}
// Enforce SecurityEnforceUacIsolation
private void AdjustUacIsolationRequest(ElevationRequest elevationRequest, bool isShellElevation)
{
if ((int)(InputArguments.GetIntegrityLevel()) >= ProcessHelper.GetCurrentIntegrityLevel())
{
if (!elevationRequest.NewWindow)
{
if (isShellElevation)
{
// force auto shell elevation in new window
elevationRequest.NewWindow = true;
// do not wait by default on this scenario, only if user has requested it.
elevationRequest.Wait = InputArguments.Wait;
Logger.Instance.Log("Elevating shell in a new console window because of SecurityEnforceUacIsolation", LogLevel.Info);
}
else
{
// force raw mode (that disables user input with SecurityEnforceUacIsolation)
elevationRequest.Mode = ElevationRequest.ConsoleMode.Piped;
Logger.Instance.Log("User Input disabled because of SecurityEnforceUacIsolation. Press Ctrl-C three times to abort. Or use -n argument to elevate in new window.", LogLevel.Warning);
}
}
}
}
private static IProcessHost CreateProcessHost(ElevationRequest request)
{
if (request.Mode == ElevationRequest.ConsoleMode.TokenSwitch)
{
return(new TokenSwitchHost());
}
if (request.NewWindow || !request.Wait)
{
return(new NewWindowProcessHost());
}
if (request.Mode == ElevationRequest.ConsoleMode.Attached)
{
return(new AttachedConsoleHost());
}
else if (request.Mode == ElevationRequest.ConsoleMode.VT)
{
return(new VTProcessHost());
}
else
{
return(new PipedProcessHost());
}
}
public void ElevationWhenPathTest()
{
var coordinate1 = new Coordinate(40.7141289, -73.9614074);
var coordinate2 = new Coordinate(40.714128899999999, -73.961407399999999);
var request = new ElevationRequest
{
Key = this.ApiKey,
Path = new[]
{
coordinate1,
coordinate2
},
Samples = 2
};
var response = GoogleMaps.Elevation.Query(request);
Assert.IsNotNull(response);
Assert.AreEqual(Status.Ok, response.Status);
Assert.AreEqual(2, response.Results.Count());
var result1 = response.Results.FirstOrDefault();
Assert.IsNotNull(result1);
Assert.AreEqual(16.9243183135986, result1.Elevation, 0.1);
Assert.AreEqual(coordinate1.Latitude, result1.Location.Latitude);
Assert.AreEqual(coordinate1.Longitude, result1.Location.Longitude);
Assert.AreEqual(76.35161590576172, result1.Resolution, 0.5);
var result2 = response.Results.FirstOrDefault();
Assert.IsNotNull(result2);
Assert.AreEqual(16.9243183135986, result2.Elevation, 0.1);
Assert.AreEqual(coordinate2.Latitude, result2.Location.Latitude);
Assert.AreEqual(coordinate2.Longitude, result2.Location.Longitude);
Assert.AreEqual(76.35161590576172, result2.Resolution, 0.5);
}
// Gets Elevation
private string GetElevation(double latitude, double longitude)
{
try
{
var elevationRequest = new ElevationRequest
{
Locations = new[] { new Location(latitude, longitude) },
};
var task = GoogleMaps.Elevation.Query(elevationRequest);
if (task.Results.Count() > 0)
{
return(task.Results.First().Elevation.ToString());
}
else
{
return("-1000");
}
}
catch (Exception ex)
{
return("-1000");
}
}
/// <summary>
/// Single elevation mode means no service is kept running. Also the command line shown in UAC is a little bit more explicit.
/// </summary>
/// <param name="elevationRequest"></param>
/// <returns></returns>
private async Task<int> RunUsingSingleUseElevation(ElevationRequest elevationRequest)
{
Logger.Instance.Log($"Using Console mode {ElevationRequest.ConsoleMode.TokenSwitch}", LogLevel.Debug);
TokenSwitchRenderer renderer = null;
try
{
renderer = new TokenSwitchRenderer(null, elevationRequest);
}
catch (Exception ex)
{
Logger.Instance.Log($"TokenSwitchRenderer mode failed with {ex.ToString()}. Fallback to Attached Mode", LogLevel.Debug);
elevationRequest.Mode = ElevationRequest.ConsoleMode.Attached; // fallback to attached mode.
return await RunUsingElevatedService(elevationRequest).ConfigureAwait(false);
}
if (StartSingleUseElevatedService(elevationRequest.TargetProcessId))
return await renderer.GetResult().ConfigureAwait(false);
else
{
renderer.TerminateProcess();
return Constants.GSUDO_ERROR_EXITCODE;
}
}
public void ConstructorDefaultTest()
{
var request = new ElevationRequest();
Assert.IsTrue(request.IsSsl);
}
public async Task <Connection> Connect(ElevationRequest elevationRequest, int?clientPid, int timeoutMilliseconds)
{
var localServer = true;
var server = ".";
string pipeName = null;
string user = System.Security.Principal.WindowsIdentity.GetCurrent().User.Value;
NamedPipeClientStream dataPipe = null;
NamedPipeClientStream controlPipe = null;
try
{
if (clientPid.HasValue)
{
pipeName = NamedPipeServer.GetPipeName(user, clientPid.Value);
if (!ExistsNamedPipe(pipeName) && timeoutMilliseconds <= 300)
{
// fail fast without timeout.
return(null);
}
}
else if (localServer)
{
var callerProcess = Process.GetCurrentProcess().ParentProcess();
while (callerProcess != null)
{
pipeName = NamedPipeServer.GetPipeName(user, callerProcess.Id);
// Does the pipe exists?
if (ExistsNamedPipe(pipeName) && timeoutMilliseconds <= 300)
{
break;
}
// try grandfather.
callerProcess = callerProcess.ParentProcess();
}
if (callerProcess == null)
{
return(null);
}
}
if (pipeName == null)
{
return(null);
}
dataPipe = new NamedPipeClientStream(server, pipeName, PipeDirection.InOut, PipeOptions.Asynchronous, System.Security.Principal.TokenImpersonationLevel.Impersonation, HandleInheritability.None);
await dataPipe.ConnectAsync(timeoutMilliseconds).ConfigureAwait(false);
controlPipe = new NamedPipeClientStream(server, pipeName + "_control", PipeDirection.InOut, PipeOptions.Asynchronous, System.Security.Principal.TokenImpersonationLevel.Impersonation, HandleInheritability.None);
await controlPipe.ConnectAsync(timeoutMilliseconds).ConfigureAwait(false);
Logger.Instance.Log($"Connected via Named Pipe {pipeName}.", LogLevel.Debug);
var conn = new Connection()
{
ControlStream = controlPipe,
DataStream = dataPipe,
};
return(conn);
}
catch
{
dataPipe?.Dispose();
controlPipe?.Dispose();
throw;
}
}
public VTClientRenderer(Connection connection, ElevationRequest elevationRequest)
{
_connection = connection;
_elevationRequest = elevationRequest;
}
public ElevationResponse GetElevation(ElevationRequest request)
{
return(new ElevationEngine().GetElevation(request));
}
public void GetElevationWithoutParameters()
{
// test
var request = new ElevationRequest();
var response = ElevationService.GetResponse(request);
}
static void Main(string[] args)
{
// Driving directions
//var drivingDirectionRequest = new DirectionsRequest
//{
// Origin = "NYC, 5th and 39",
// Destination = "Philladephia, Chesnut and Wallnut"
//};
var drivingDirectionRequest = new DirectionsRequest
{
TravelMode = TravelMode.Walking,
Origin = "Ha-Va'ad ha-Le'umi 21, JERUSALEM, ISRAEL",
//Destination = "kfar ivri ,10, Jerusalem,israel"
Destination = "31.8414894,35.2471631"
};
DirectionsResponse drivingDirections = GoogleMaps.Directions.Query(drivingDirectionRequest);
Leg leg = PrintDirections(drivingDirections);
Console.WriteLine("**********");
Console.WriteLine(leg.Distance.Text);
Console.WriteLine(leg.Duration.Text);
Console.WriteLine("*****************");
drivingDirectionRequest.TravelMode = TravelMode.Driving;
DirectionsResponse drivingDirections2 = GoogleMaps.Directions.Query(drivingDirectionRequest);
Leg leg2 = PrintDirections(drivingDirections2);
Console.WriteLine("**********");
Console.WriteLine(leg2.Distance.Text);
Console.WriteLine(leg2.Duration.Text);
Console.WriteLine("*****************");
Console.ReadKey();
// Transit directions
var transitDirectionRequest = new DirectionsRequest
{
Origin = "New York",
Destination = "Queens",
TravelMode = TravelMode.Transit,
DepartureTime = DateTime.Now
};
DirectionsResponse transitDirections = GoogleMaps.Directions.Query(transitDirectionRequest);
PrintDirections(transitDirections);
var dep_time = DateTime.Today
.AddDays(1)
.AddHours(13);
var request = new DirectionsRequest
{
Origin = "T-centralen, Stockholm, Sverige",
Destination = "Kungsträdgården, Stockholm, Sverige",
TravelMode = TravelMode.Transit,
DepartureTime = dep_time,
Language = "sv"
};
DirectionsResponse result = GoogleMaps.Directions.Query(request);
PrintDirections(result);
// Geocode
//https://maps.googleapis.com/maps/api/geocode/json?address=Parque+Marechal+Mascarenhas+de+Morais&components=locality:Porto%20Aelgre|administrative_area:RS|country:BR
var geocodeRequest = new GeocodingRequest
{
Address = "Parque Marechal Mascarenhas de Morais",
Components = new GeocodingComponents()
{
Locality = "Porto Alegre",
AdministrativeArea = "RS",
Country = "BR"
}
};
GeocodingResponse geocode = GoogleMaps.Geocode.Query(geocodeRequest);
Console.WriteLine(geocode);
// Static maps API - get static map of with the path of the directions request
var staticMapGenerator = new StaticMapsEngine();
//Path from previous directions request
IEnumerable <Step> steps = drivingDirections.Routes.First().Legs.First().Steps;
// All start locations
IList <ILocationString> path = steps.Select(step => step.StartLocation).ToList <ILocationString>();
// also the end location of the last step
path.Add(steps.Last().EndLocation);
string url = staticMapGenerator.GenerateStaticMapURL(new StaticMapRequest(new Location(40.38742, -74.55366), 9, new ImageSize(800, 400))
{
Pathes = new List <Path> {
new Path
{
Style = new PathStyle
{
Color = "red"
},
Locations = path
}
},
ApiKey = string.Empty //Pass the API Key here. if it is passed as non empty value, then it will be appended in request URL
});
Console.WriteLine("Map with path: " + url);
// Async! (Elevation)
var elevationRequest = new ElevationRequest
{
Locations = new[] { new Location(54, 78) },
};
var task = GoogleMaps.Elevation.QueryAsync(elevationRequest)
.ContinueWith(t => Console.WriteLine("\n" + t.Result));
Console.Write("Asynchronous query sent, waiting for a reply..");
while (!task.IsCompleted)
{
Console.Write('.');
Thread.Sleep(1000);
}
Console.WriteLine("Finished! Press any key to exit...");
Console.ReadKey();
}
public static ElevationResponse GetElevation(ElevationRequest request)
{
return(MapsAPIEngine.GetElevation(request));
}
/// <summary>
/// Sends the specified request to the Google Maps Elevation web
/// service and parses the response as an ElevationResponse
/// object.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public static ElevationResponse GetResponse(ElevationRequest request)
{
var url = new Uri(ApiUrl, request.ToUri());
return Http.Get(url).As<ElevationResponse>();
}
void ButtonSetLocationClick(object sender, EventArgs e)
{
double lat = Globals.latitute;
double lng = Globals.longitude;
try
{
lat = double.Parse(textBoxLatitude.Text.Replace(',', '.'), GUI.cords, System.Globalization.NumberFormatInfo.InvariantInfo);
if (lat > 90.0 || lat < -90.0)
{
throw new System.ArgumentException("Value has to be between 90 and -90!");
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
textBoxLatitude.Text = "";
}
try
{
lng = double.Parse(textBoxLongitude.Text.Replace(',', '.'), GUI.cords, System.Globalization.NumberFormatInfo.InvariantInfo);
if (lng > 180.0 || lng < -180.0)
{
throw new System.ArgumentException("Value has to be between 180 and -180!");
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
textBoxLongitude.Text = "";
}
if (lat != Globals.latitute && lng != Globals.longitude)
{
if ((!lat.Equals(Globals.latitute)) && (!lng.Equals(Globals.longitude)))
{
Globals.latitute = lat;
Globals.longitude = lng;
var elevationRequest = new ElevationRequest()
{
Locations = new[] { new Location(lat, lng) },
};
if (Globals.GoogleMapsAPIKey != "")
{
elevationRequest.ApiKey = Globals.GoogleMapsAPIKey;
}
try
{
ElevationResponse elevation = GoogleMaps.Elevation.Query(elevationRequest);
if (elevation.Status == Status.OK)
{
foreach (Result result in elevation.Results)
{
Globals.altitude = result.Elevation;
}
}
}
catch (Exception)
{
// ignored
}
Globals.RelocateDefaultLocation = true;
numTravelSpeed.Value = 0;
textBoxLatitude.Text = "";
textBoxLongitude.Text = "";
Logger.ColoredConsoleWrite(ConsoleColor.Green, "Default Location Set will navigate there after next pokestop!");
}
}
}
public async Task <int> Execute()
{
//Logger.Instance.Log("Params: " + Newtonsoft.Json.JsonConvert.SerializeObject(this), LogLevel.Debug);
var currentProcess = System.Diagnostics.Process.GetCurrentProcess();
bool emptyArgs = string.IsNullOrEmpty(CommandToRun.FirstOrDefault());
CommandToRun = ArgumentsHelper.AugmentCommand(CommandToRun.ToArray());
bool isWindowsApp = ProcessFactory.IsWindowsApp(CommandToRun.FirstOrDefault());
var consoleMode = GetConsoleMode(isWindowsApp);
if (!RunningAsDesiredUser())
{
CommandToRun = AddCopyEnvironment(CommandToRun);
}
var exeName = CommandToRun.FirstOrDefault();
var elevationRequest = new ElevationRequest()
{
FileName = exeName,
Arguments = GetArguments(),
StartFolder = Environment.CurrentDirectory,
NewWindow = GlobalSettings.NewWindow,
Wait = (!isWindowsApp && !GlobalSettings.NewWindow) || GlobalSettings.Wait,
Mode = consoleMode,
ConsoleProcessId = currentProcess.Id,
Prompt = consoleMode != ElevationRequest.ConsoleMode.Raw || GlobalSettings.NewWindow ? GlobalSettings.Prompt : GlobalSettings.RawPrompt
};
Logger.Instance.Log($"Command to run: {elevationRequest.FileName} {elevationRequest.Arguments}", LogLevel.Debug);
if (elevationRequest.Mode == ElevationRequest.ConsoleMode.VT)
{
elevationRequest.ConsoleWidth = Console.WindowWidth;
elevationRequest.ConsoleHeight = Console.WindowHeight;
if (TerminalHelper.IsConEmu())
{
elevationRequest.ConsoleWidth--; // weird ConEmu/Cmder fix
}
}
if (RunningAsDesiredUser()) // already elevated or running as correct user. No service needed.
{
if (emptyArgs && !GlobalSettings.NewWindow)
{
Logger.Instance.Log("Already elevated (and no parameters specified). Exiting...", LogLevel.Error);
return(Constants.GSUDO_ERROR_EXITCODE);
}
Logger.Instance.Log("Already elevated. Running in-process", LogLevel.Debug);
// No need to escalate. Run in-process
if (elevationRequest.Mode == ElevationRequest.ConsoleMode.Raw && !elevationRequest.NewWindow)
{
if (!string.IsNullOrEmpty(GlobalSettings.RawPrompt.Value))
{
Environment.SetEnvironmentVariable("PROMPT", Environment.ExpandEnvironmentVariables(GlobalSettings.RawPrompt.Value));
}
}
else
{
if (!string.IsNullOrEmpty(GlobalSettings.Prompt.Value))
{
Environment.SetEnvironmentVariable("PROMPT", Environment.ExpandEnvironmentVariables(GlobalSettings.Prompt.Value));
}
}
if (GlobalSettings.NewWindow)
{
using (Process process = ProcessFactory.StartDetached(exeName, GetArguments(), Environment.CurrentDirectory, false))
{
if (elevationRequest.Wait)
{
process.WaitForExit();
var exitCode = process.ExitCode;
Logger.Instance.Log($"Elevated process exited with code {exitCode}", exitCode == 0 ? LogLevel.Debug : LogLevel.Info);
return(exitCode);
}
return(0);
}
}
else
{
using (Process process = ProcessFactory.StartInProcessAtached(exeName, GetArguments()))
{
process.WaitForExit();
var exitCode = process.ExitCode;
Logger.Instance.Log($"Elevated process exited with code {exitCode}", exitCode == 0 ? LogLevel.Debug : LogLevel.Info);
return(exitCode);
}
}
}
else
{
Logger.Instance.Log($"Using Console mode {elevationRequest.Mode}", LogLevel.Debug);
var callingPid = GetCallingPid(currentProcess);
var callingSid = WindowsIdentity.GetCurrent().User.Value;
Logger.Instance.Log($"Caller PID: {callingPid}", LogLevel.Debug);
Logger.Instance.Log($"Caller SID: {callingSid}", LogLevel.Debug);
var cmd = CommandToRun.FirstOrDefault();
var rpcClient = GetClient(elevationRequest);
Rpc.Connection connection = null;
try
{
try
{
connection = await rpcClient.Connect(elevationRequest, null, 300).ConfigureAwait(false);
}
catch (System.IO.IOException) { }
catch (TimeoutException) { }
catch (Exception ex)
{
Logger.Instance.Log(ex.ToString(), LogLevel.Warning);
}
if (connection == null) // service is not running or listening.
{
// Start elevated service instance
if (!StartElevatedService(currentProcess, callingPid, callingSid))
{
return(Constants.GSUDO_ERROR_EXITCODE);
}
connection = await rpcClient.Connect(elevationRequest, callingPid, 5000).ConfigureAwait(false);
}
if (connection == null) // service is not running or listening.
{
Logger.Instance.Log("Unable to connect to the elevated service.", LogLevel.Error);
return(Constants.GSUDO_ERROR_EXITCODE);
}
await WriteElevationRequest(elevationRequest, connection).ConfigureAwait(false);
ConnectionKeepAliveThread.Start(connection);
var renderer = GetRenderer(connection, elevationRequest);
var exitCode = await renderer.Start().ConfigureAwait(false);
if (!(elevationRequest.NewWindow && !elevationRequest.Wait))
{
Logger.Instance.Log($"Elevated process exited with code {exitCode}", exitCode == 0 ? LogLevel.Debug : LogLevel.Info);
}
return(exitCode);
}
finally
{
connection?.Dispose();
}
}
}
public async Task <int> Execute()
{
int? exitCode;
bool isRunningAsDesiredUser = IsRunningAsDesiredUser();
bool isElevationRequired = IsElevationRequired();
bool isShellElevation = string.IsNullOrEmpty(CommandToRun.FirstOrDefault()); // are we auto elevating the current shell?
if (isElevationRequired & ProcessHelper.GetCurrentIntegrityLevel() < (int)IntegrityLevel.Medium)
{
throw new ApplicationException("Sorry, gsudo doesn't allow to elevate from low integrity level."); // This message is not a security feature, but a nicer error message. It would have failed anyway since the named pipe's ACL restricts it.
}
CommandToRun = ArgumentsHelper.AugmentCommand(CommandToRun.ToArray());
bool isWindowsApp = ProcessFactory.IsWindowsApp(CommandToRun.FirstOrDefault());
var elevationMode = GetElevationMode(isWindowsApp);
if (!isRunningAsDesiredUser)
{
CommandToRun = AddCopyEnvironment(CommandToRun, elevationMode);
}
var exeName = CommandToRun.FirstOrDefault();
var elevationRequest = new ElevationRequest()
{
FileName = exeName,
Arguments = GetArguments(),
StartFolder = Environment.CurrentDirectory,
NewWindow = InputArguments.NewWindow,
Wait = (!isWindowsApp && !InputArguments.NewWindow) || InputArguments.Wait,
Mode = elevationMode,
ConsoleProcessId = Process.GetCurrentProcess().Id,
IntegrityLevel = InputArguments.GetIntegrityLevel(),
};
if (isElevationRequired && Settings.SecurityEnforceUacIsolation)
{
AdjustUacIsolationRequest(elevationRequest, isShellElevation);
}
SetRequestPrompt(elevationRequest);
Logger.Instance.Log($"Command to run: {elevationRequest.FileName} {elevationRequest.Arguments}", LogLevel.Debug);
if (elevationRequest.Mode == ElevationRequest.ConsoleMode.VT)
{
elevationRequest.ConsoleWidth = Console.WindowWidth;
elevationRequest.ConsoleHeight = Console.WindowHeight;
if (TerminalHelper.IsConEmu())
{
elevationRequest.ConsoleWidth--; // weird ConEmu/Cmder fix
}
}
if (isRunningAsDesiredUser && isShellElevation && !InputArguments.NewWindow)
{
Logger.Instance.Log("Already running as the specified user/permission-level (and no command specified). Exiting...", LogLevel.Error);
return(Constants.GSUDO_ERROR_EXITCODE);
}
if (isRunningAsDesiredUser || !isElevationRequired) // already elevated or running as correct user. No service needed.
{
return(RunWithoutService(exeName, GetArguments(), elevationRequest));
}
if (Settings.CacheMode.Value.In(CacheMode.Disabled) ||
Math.Abs(Settings.CacheDuration.Value.TotalSeconds) < 1 ||
(InputArguments.KillCache && !IsServiceAvailable()))
{
exitCode = await RunUsingSingleUseElevation(elevationRequest).ConfigureAwait(false);
}
else if (Settings.CacheMode.Value.In(CacheMode.Auto) ||
elevationRequest.Mode != ElevationRequest.ConsoleMode.TokenSwitch)
{
exitCode = await RunUsingElevatedService(elevationRequest).ConfigureAwait(false);
}
else if (Settings.CacheMode.Value == CacheMode.Explicit && IsServiceAvailable())
{
exitCode = await RunUsingElevatedService(elevationRequest).ConfigureAwait(false);
}
else
{
exitCode = await RunUsingSingleUseElevation(elevationRequest).ConfigureAwait(false);
}
if (exitCode.HasValue && exitCode.Value != Constants.GSUDO_ERROR_EXITCODE)
{
Logger.Instance.Log($"Process exited with code {exitCode}", exitCode == 0 ? LogLevel.Debug : LogLevel.Info);
}
return(exitCode ?? 0);
}
static void Main(string[] args)
{
//Static class use (Directions)
DirectionsRequest directionsRequest = new DirectionsRequest()
{
Origin = "NYC, 5th and 39",
Destination = "Philladephia, Chesnut and Wallnut",
};
DirectionsResponse directions = MapsAPI.GetDirections(directionsRequest);
Console.WriteLine(directions);
//Instance class use (Geocode)
GeocodingRequest geocodeRequest = new GeocodingRequest()
{
Address = "new york city",
};
GeocodingEngine geocodingEngine = new GeocodingEngine();
GeocodingResponse geocode = geocodingEngine.GetGeocode(geocodeRequest);
Console.WriteLine(geocode);
// Static maps API - get static map of with the path of the directions request
StaticMapsEngine staticMapGenerator = new StaticMapsEngine();
//Path from previos directions request
IEnumerable <Step> steps = directions.Routes.First().Legs.First().Steps;
// All start locations
IList <ILocation> path = steps.Select(step => step.StartLocation).ToList <ILocation>();
// also the end location of the last step
path.Add(steps.Last().EndLocation);
string url = staticMapGenerator.GenerateStaticMapURL(new StaticMapRequest(new Location(40.38742, -74.55366), 9, new ImageSize(800, 400))
{
Pathes = new List <Path>()
{
new Path()
{
Style = new PathStyle()
{
Color = "red"
},
Locations = path
}
}
});
Console.WriteLine("Map with path: " + url);
//Instance class - Async! (Elevation)
ElevationRequest elevationRequest = new ElevationRequest()
{
Locations = new Location[] { new Location(54, 78) },
};
ElevationEngine elevationEngine = new ElevationEngine();
elevationEngine.BeginGetElevation(elevationRequest,
ar =>
{
ElevationResponse elevation = elevationEngine.EndGetElevation(ar);
Console.WriteLine(elevation);
},
null);
Console.WriteLine("Finised! (But wait .. async elevation request should get response soon)");
Console.ReadKey();
}
static void Main(string[] args)
{
// Driving directions
var drivingDirectionRequest = new DirectionsRequest
{
Origin = "NYC, 5th and 39",
Destination = "Philladephia, Chesnut and Wallnut"
};
DirectionsResponse drivingDirections = GoogleMaps.Directions.Query(drivingDirectionRequest);
PrintDirections(drivingDirections);
// Transit directions
var transitDirectionRequest = new DirectionsRequest
{
Origin = "New York",
Destination = "Queens",
TravelMode = TravelMode.Transit,
DepartureTime = DateTime.Now
};
DirectionsResponse transitDirections = GoogleMaps.Directions.Query(transitDirectionRequest);
PrintDirections(transitDirections);
var dep_time = DateTime.Today
.AddDays(1)
.AddHours(13);
var request = new DirectionsRequest
{
Origin = "T-centralen, Stockholm, Sverige",
Destination = "Kungsträdgården, Stockholm, Sverige",
TravelMode = TravelMode.Transit,
DepartureTime = dep_time,
Language = "sv"
};
DirectionsResponse result = GoogleMaps.Directions.Query(request);
PrintDirections(result);
// Geocode
var geocodeRequest = new GeocodingRequest
{
Address = "new york city",
};
GeocodingResponse geocode = GoogleMaps.Geocode.Query(geocodeRequest);
Console.WriteLine(geocode);
// Static maps API - get static map of with the path of the directions request
var staticMapGenerator = new StaticMapsEngine();
//Path from previous directions request
IEnumerable <Step> steps = drivingDirections.Routes.First().Legs.First().Steps;
// All start locations
IList <ILocationString> path = steps.Select(step => step.StartLocation).ToList <ILocationString>();
// also the end location of the last step
path.Add(steps.Last().EndLocation);
string url = staticMapGenerator.GenerateStaticMapURL(new StaticMapRequest(new Location(40.38742, -74.55366), 9, new ImageSize(800, 400))
{
Pathes = new List <Path> {
new Path
{
Style = new PathStyle
{
Color = "red"
},
Locations = path
}
}
});
Console.WriteLine("Map with path: " + url);
// Async! (Elevation)
var elevationRequest = new ElevationRequest
{
Locations = new[] { new Location(54, 78) },
};
var task = GoogleMaps.Elevation.QueryAsync(elevationRequest)
.ContinueWith(t => Console.WriteLine("\n" + t.Result));
Console.Write("Asynchronous query sent, waiting for a reply..");
while (!task.IsCompleted)
{
Console.Write('.');
Thread.Sleep(1000);
}
Console.WriteLine("Finished! Press any key to exit...");
Console.ReadKey();
}
#pragma warning disable IDE0060,CA1801 // Remove unused parameter (reserved for future use)
private IRpcClient GetClient(ElevationRequest elevationRequest)
#pragma warning restore IDE0060,CA1801 // Remove unused parameter
{
// future Tcp implementations should be plugged here.
return(new NamedPipeClient());
}
private static int RunWithoutService(string exeName, string args, ElevationRequest elevationRequest)
{
Logger.Instance.Log("Already running as the specified user/permission-level. Running in-process...", LogLevel.Debug);
var sameIntegrity = (int)InputArguments.GetIntegrityLevel() == ProcessHelper.GetCurrentIntegrityLevel();
// No need to escalate. Run in-process
Native.ConsoleApi.SetConsoleCtrlHandler(ConsoleHelper.IgnoreConsoleCancelKeyPress, true);
if (!string.IsNullOrEmpty(elevationRequest.Prompt))
{
Environment.SetEnvironmentVariable("PROMPT", Environment.ExpandEnvironmentVariables(elevationRequest.Prompt));
}
if (sameIntegrity)
{
if (elevationRequest.NewWindow)
{
using (var process = ProcessFactory.StartDetached(exeName, args, Environment.CurrentDirectory, false))
{
if (elevationRequest.Wait)
{
process.WaitForExit();
var exitCode = process.ExitCode;
Logger.Instance.Log($"Process exited with code {exitCode}", LogLevel.Debug);
return(exitCode);
}
return(0);
}
}
else
{
using (Process process = ProcessFactory.StartAttached(exeName, args))
{
process.WaitForExit();
var exitCode = process.ExitCode;
Logger.Instance.Log($"Process exited with code {exitCode}", LogLevel.Debug);
return(exitCode);
}
}
}
else // lower integrity
{
if (elevationRequest.IntegrityLevel < IntegrityLevel.High && !elevationRequest.NewWindow)
{
RemoveAdminPrefixFromConsoleTitle();
}
var p = ProcessFactory.StartAttachedWithIntegrity(InputArguments.GetIntegrityLevel(), exeName, args, elevationRequest.StartFolder, InputArguments.NewWindow, !InputArguments.NewWindow);
if (p == null || p.IsInvalid)
{
return(Constants.GSUDO_ERROR_EXITCODE);
}
if (elevationRequest.Wait)
{
ProcessHelper.GetProcessWaitHandle(p.DangerousGetHandle()).WaitOne();
ProcessApi.GetExitCodeProcess(p, out var exitCode);
Logger.Instance.Log($"Process exited with code {exitCode}", LogLevel.Debug);
return(exitCode);
}
return(0);
}
}
public async Task Start(Connection connection, ElevationRequest request)
{
if (Settings.SecurityEnforceUacIsolation)
{
throw new NotSupportedException("VT Mode not supported when SecurityEnforceUacIsolation=true");
}
int? exitCode;
Task t1 = null, t2 = null, t3 = null;
_connection = connection;
System.Diagnostics.Process runningProcess = null;
try
{
string command = request.FileName + " " + request.Arguments;
using (var inputPipe = new PseudoConsolePipe())
using (var outputPipe = new PseudoConsolePipe())
{
using (var pseudoConsole = PseudoConsole.PseudoConsole.Create(inputPipe.ReadSide, outputPipe.WriteSide, (short)request.ConsoleWidth, (short)request.ConsoleHeight))
{
using (var process = StartPseudoConsole(command, PseudoConsole.PseudoConsole.PseudoConsoleThreadAttribute, pseudoConsole.Handle, request.StartFolder))
{
runningProcess = System.Diagnostics.Process.GetProcessById(process.ProcessInfo.dwProcessId);
// copy all pseudoconsole output to stdout
t1 = Task.Run(() => CopyPipeToOutput(outputPipe.ReadSide));
// prompt for stdin input and send the result to the pseudoconsole
t2 = Task.Run(() => CopyInputToPipe(inputPipe.WriteSide));
// discard Control stream
t3 = new StreamReader(_connection.ControlStream, Settings.Encoding).ConsumeOutput((s) => Task.CompletedTask);
Logger.Instance.Log($"Process ({process.ProcessInfo.dwProcessId}) started: {request.FileName} {request.Arguments}", LogLevel.Debug);
// free resources in case the console is ungracefully closed (e.g. by the 'x' in the window titlebar)
// var t3 = new StreamReader(pipe, Globals.Encoding).ConsumeOutput((s) => WriteToStdInput(s, process));
OnClose(() => DisposeResources(process, pseudoConsole, outputPipe, inputPipe));
WaitHandle.WaitAny(new WaitHandle[] { runningProcess.GetProcessWaitHandle(), connection.DisconnectedWaitHandle });
exitCode = process.GetExitCode();
}
}
}
if (connection.IsAlive)
{
await connection.ControlStream.WriteAsync($"{Constants.TOKEN_EXITCODE}{exitCode ?? 0}{Constants.TOKEN_EXITCODE}").ConfigureAwait(false);
}
await connection.FlushAndCloseAll().ConfigureAwait(false);
}
catch (Exception ex)
{
Logger.Instance.Log(ex.ToString(), LogLevel.Error);
await connection.ControlStream.WriteAsync($"{Constants.TOKEN_ERROR}Server Error: {ex.ToString()}\r\n{Constants.TOKEN_ERROR}").ConfigureAwait(false);
await connection.FlushAndCloseAll().ConfigureAwait(false);
return;
}
finally
{
if (runningProcess != null && !runningProcess.HasExited)
{
runningProcess.Terminate();
}
}
}
public void GetElevationWithoutParameters()
{
// test
var request = new ElevationRequest();
var response = ElevationService.GetResponse(request);
}
