private void RestartService(ServiceListViewItem serviceListViewItem)
{
try
{
using (ServiceControlManager scm = ServiceControlManager.Connect(Advapi32.ServiceControlManagerAccessRights.Connect))
{
using (ServiceHandle serviceHandle = scm.OpenService(serviceListViewItem.ServiceName, Advapi32.ServiceAccessRights.QueryStatus | Advapi32.ServiceAccessRights.Start | Advapi32.ServiceAccessRights.Stop))
{
Advapi32.ServiceStatusProcess status = serviceHandle.QueryServiceStatus();
//Stop service (throws an exception if it is stopped)
serviceHandle.Stop();
//Wait for stop
serviceHandle.WaitForStatus(Advapi32.ServiceCurrentState.Stopped, TimeSpan.FromSeconds(10));
//Start service
serviceHandle.Start();
}
}
}
catch (System.TimeoutException)
{
MessageBox.Show(_resManager.GetString("timeout_exception_service_restart"), _resManager.GetString("error"), MessageBoxButton.OK, MessageBoxImage.Error);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, _resManager.GetString("error"), MessageBoxButton.OK, MessageBoxImage.Error);
}
}
static bool StopService(Options opt)
{
bool bResult = false;
try
{
bool IsWindows = System.Runtime.InteropServices.RuntimeInformation
.IsOSPlatform(System.Runtime.InteropServices.OSPlatform.Windows);
if (IsWindows == true)
{
ServiceControlManager mgr = ServiceControlManager.Connect(Win32ServiceInterop.Wrapper, null, null, ServiceControlManagerAccessRights.All);
if ((mgr != null) && (mgr.IsInvalid != true))
{
ServiceHandle h = mgr.OpenService(ServiceName, ServiceControlAccessRights.All);
if (h != null)
{
ServiceStatusProcess status = new ServiceStatusProcess();
uint reason = (uint)StopReasonMinorReasonFlags.SERVICE_STOP_REASON_MINOR_MAINTENANCE |
(uint)StopReasonMajorReasonFlags.SERVICE_STOP_REASON_MAJOR_NONE |
(uint)StopReasonFlags.SERVICE_STOP_REASON_FLAG_UNPLANNED;
ServiceStatusParam param = new ServiceStatusParam(reason, status);
int s = Marshal.SizeOf <ServiceStatusParam>();
var lpParam = Marshal.AllocHGlobal(s);
Marshal.StructureToPtr(param, lpParam, fDeleteOld: false);
if (Win32ServiceInterop.ControlServiceExW(h, (uint)ServiceControlCommandFlags.SERVICE_CONTROL_STOP, (uint)ServiceControlCommandReasonFlags.SERVICE_CONTROL_STATUS_REASON_INFO, lpParam) == true)
{
bResult = true;
}
else
{
opt.LogError("Stop feature: can't stop Service: " + ServiceName + " ErrorCode: " + Marshal.GetLastWin32Error().ToString());
}
}
else
{
opt.LogError("Stop feature: can't open Service: " + ServiceName);
}
}
else
{
opt.LogError("Stop feature: can't open ServiceManager");
}
}
else
{
opt.LogError("Stop feature: this service is not available on the current platform");
}
}
catch (Exception ex)
{
opt.LogError("Stop feature: exception: " + ex.Message);
}
return(bResult);
}
static bool StartService(Options opt)
{
bool bResult = false;
try
{
bool IsWindows = System.Runtime.InteropServices.RuntimeInformation
.IsOSPlatform(System.Runtime.InteropServices.OSPlatform.Windows);
if (IsWindows == true)
{
ServiceControlManager mgr = ServiceControlManager.Connect(Win32ServiceInterop.Wrapper, null, null, ServiceControlManagerAccessRights.All);
if ((mgr != null) && (mgr.IsInvalid != true))
{
ServiceHandle h = mgr.OpenService(ServiceName, ServiceControlAccessRights.All);
if (h != null)
{
if (Win32ServiceInterop.StartServiceW(h, 0, IntPtr.Zero) == true)
{
bResult = true;
}
else
{
opt.LogError("Start feature: can't start Service: " + ServiceName);
}
}
else
{
opt.LogError("Start feature: can't open Service: " + ServiceName);
}
}
else
{
opt.LogError("Start feature: can't open ServiceManager");
}
}
else
{
opt.LogError("Start feature: this service is not available on the current platform");
}
}
catch (Exception ex)
{
opt.LogError("Start feature: exception: " + ex.Message);
}
return(bResult);
}
private void StopService(ServiceListViewItem serviceListViewItem)
{
try
{
using (ServiceControlManager scm = ServiceControlManager.Connect(Advapi32.ServiceControlManagerAccessRights.Connect))
{
using (ServiceHandle serviceHandle = scm.OpenService(serviceListViewItem.ServiceName, Advapi32.ServiceAccessRights.Stop))
{
serviceHandle.Stop();
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, _resManager.GetString("error"), MessageBoxButton.OK, MessageBoxImage.Error);
}
}
private void RemoveDaemon(ServiceListViewItem serviceListViewItem)
{
MessageBoxResult result = MessageBox.Show(_resManager.GetString("msg_warning_delete"), _resManager.GetString("question"),
MessageBoxButton.YesNo, MessageBoxImage.Question);
if (result != MessageBoxResult.Yes)
{
return;
}
try
{
using (ServiceControlManager scm = ServiceControlManager.Connect(Advapi32.ServiceControlManagerAccessRights.Connect))
{
using (ServiceHandle serviceHandle = scm.OpenService(serviceListViewItem.ServiceName, Advapi32.ServiceAccessRights.AllAccess))
{
serviceHandle.DeleteService();
}
}
_processCollection.Remove(_processCollection.Single(i => i.ServiceName == serviceListViewItem.ServiceName));
//MessageBox.Show(_resManager.GetString("the_service_deletion_was_successful"),
// _resManager.GetString("success"), MessageBoxButton.OK, MessageBoxImage.Information);
}
catch (ServiceNotStoppedException)
{
result = MessageBox.Show(_resManager.GetString("you_must_stop_the_service_first"),
_resManager.GetString("information"), MessageBoxButton.YesNo, MessageBoxImage.Information);
if (result == MessageBoxResult.Yes)
{
StopService(serviceListViewItem);
}
}
catch (Exception ex)
{
MessageBox.Show(_resManager.GetString("the_service_deletion_was_unsuccessful") + "\n" + ex.Message, _resManager.GetString("error"), MessageBoxButton.OK, MessageBoxImage.Error);
}
}
private void KillService(ServiceListViewItem serviceListViewItem)
{
try
{
using (ServiceControlManager scm = ServiceControlManager.Connect(Advapi32.ServiceControlManagerAccessRights.Connect))
{
using (ServiceHandle serviceHandle = scm.OpenService(serviceListViewItem.ServiceName, Advapi32.ServiceAccessRights.UserDefinedControl | Advapi32.ServiceAccessRights.QueryStatus))
{
if (serviceHandle.QueryServiceStatus().currentState == Advapi32.ServiceCurrentState.Stopped)
{
return;
}
try
{
serviceHandle.ExecuteCommand((int)ServiceCommands.ServiceKillProcessAndStop);
serviceHandle.WaitForStatus(Advapi32.ServiceCurrentState.Stopped, TimeSpan.FromSeconds(2));
}
catch (TimeoutException)
{
if (KillChildProcessJob.IsSupportedWindowsVersion && serviceListViewItem.ServicePid != null)
{
Process process = Process.GetProcessById((int)serviceListViewItem.ServicePid);
process.Kill();
}
else
{
MessageBox.Show(_resManager.GetString("cannot_kill_service", CultureInfo.CurrentUICulture), _resManager.GetString("error"), MessageBoxButton.OK, MessageBoxImage.Error);
}
}
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, _resManager.GetString("error"), MessageBoxButton.OK, MessageBoxImage.Error);
}
}
private void StartService(ServiceListViewItem serviceListViewItem, bool inUserSession = false)
{
try
{
if (inUserSession)
{
//Write username where the service should start the process
RegistryManagement.WriteSessionUsername(serviceListViewItem.ServiceName, WindowsIdentity.GetCurrent().Name);
}
using (ServiceControlManager scm = ServiceControlManager.Connect(Advapi32.ServiceControlManagerAccessRights.Connect))
{
using (ServiceHandle serviceHandle = scm.OpenService(serviceListViewItem.ServiceName, Advapi32.ServiceAccessRights.Start))
{
serviceHandle.Start();
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, _resManager.GetString("error"), MessageBoxButton.OK, MessageBoxImage.Error);
}
}
public static ActionResult DeleteAllServices(Session session)
{
string appFolder = session.CustomActionData["APPDIR"];
if (string.IsNullOrWhiteSpace(appFolder) || !Directory.Exists(appFolder))
{
session.Log("AppFolder is null or invalid.");
return(ActionResult.Failure);
}
session.Log("Beginning the uninstall of all services.");
try
{
using (ServiceControlManager controlManager = ServiceControlManager.Connect(Advapi32.ServiceControlManagerAccessRights.Connect))
{
//Get all services for this installation
List <string> serviceNameList = new List <string>();
using (RegistryKey mainKey = Registry.LocalMachine.OpenSubKey(@"SYSTEM\CurrentControlSet\Services\", RegistryKeyPermissionCheck.ReadSubTree))
{
if (mainKey == null)
{
return(ActionResult.Failure);
}
foreach (string serviceName in mainKey.GetSubKeyNames())
{
using (RegistryKey key = mainKey.OpenSubKey(serviceName, RegistryKeyPermissionCheck.ReadSubTree))
{
//If the key invalid, skip this service
if (key == null)
{
continue;
}
//Get the exe path of the service to determine later if its a service from DaemonMaster
string serviceExePath = Convert.ToString(key.GetValue("ImagePath") ?? string.Empty);
if (string.IsNullOrWhiteSpace(serviceExePath) || !DaemonMasterUtils.ComparePaths(serviceExePath, appFolder + ServiceControlManager.DmServiceFileName)) //Not possible to use ServiceControlManager.DmServiceExe because the AppDomain changed here => so that we need to rebuilt the path.
{
continue;
}
serviceNameList.Add(serviceName);
}
}
}
foreach (string serviceName in serviceNameList)
{
using (ServiceHandle service = controlManager.OpenService(serviceName, Advapi32.ServiceAccessRights.AllAccess))
{
session.Log("Try to delete " + serviceName);
try
{
Advapi32.ServiceStatusProcess serviceStatus = service.QueryServiceStatus();
if (serviceStatus.currentState != Advapi32.ServiceCurrentState.Stopped)
{
session.Log("Try killing " + serviceName + " service.");
service.ExecuteCommand((int)ServiceCommands.ServiceKillProcessAndStop);
try
{
service.WaitForStatus(Advapi32.ServiceCurrentState.Stopped, TimeSpan.FromSeconds(5));
}
catch (TimeoutException)
{
session.Log("Terminate " + serviceName + " service.");
Process process = Process.GetProcessById((int)serviceStatus.processId);
process.Kill();
}
}
service.DeleteService();
session.Log("Deleted " + serviceName + " service successful.");
}
catch (Exception e)
{
session.Log("Deletion of " + serviceName + " failed.\n" + e.Message + "\n" + e.StackTrace);
//continue
}
}
}
}
session.Log("Uninstall of all services was successful.");
return(ActionResult.Success);
}
catch (Exception e)
{
session.Log(e.Message + "\n" + e.StackTrace);
return(ActionResult.Failure);
}
}
private void ApplyConfiguration()
{
try
{
//Only set right it is not a build in account
if (!Equals(_tempServiceConfig.Credentials, ServiceCredentials.LocalSystem) &&
!Equals(_tempServiceConfig.Credentials, ServiceCredentials.LocalService) &&
!Equals(_tempServiceConfig.Credentials, ServiceCredentials.NetworkService) &&
!Equals(_tempServiceConfig.Credentials, ServiceCredentials.NoChange) &&
!ServiceCredentials.IsVirtualAccount(_tempServiceConfig.Credentials)) //Normally all NT SERVICE\\... service has that right, so no need to add it.
{
string username = _tempServiceConfig.Credentials.Username;
if (string.IsNullOrWhiteSpace(username))
{
username = TextBoxUsername.Text;
}
using (LsaPolicyHandle lsaWrapper = LsaPolicyHandle.OpenPolicyHandle())
{
bool hasRightToStartAsService = lsaWrapper.EnumeratePrivileges(username).Any(x => x.Buffer == "SeServiceLogonRight");
if (!hasRightToStartAsService)
{
MessageBoxResult result = MessageBox.Show(_resManager.GetString("logon_as_a_service", CultureInfo.CurrentUICulture), _resManager.GetString("question", CultureInfo.CurrentUICulture), MessageBoxButton.YesNo, MessageBoxImage.Question);
if (result != MessageBoxResult.Yes)
{
return;
}
//Give the account the right to start as service
lsaWrapper.AddPrivileges(username, "SeServiceLogonRight");
}
}
}
if (_createNewService)
{
using (ServiceControlManager scm = ServiceControlManager.Connect(Advapi32.ServiceControlManagerAccessRights.CreateService))
{
scm.CreateService(_tempServiceConfig);
////When no exception has been throwed show up a message (no longer)
//MessageBox.Show(
// _resManager.GetString("the_service_installation_was_successful", CultureInfo.CurrentUICulture),
// _resManager.GetString("success", CultureInfo.CurrentUICulture), MessageBoxButton.OK, MessageBoxImage.Information);
}
}
else
{
using (ServiceControlManager scm = ServiceControlManager.Connect(Advapi32.ServiceControlManagerAccessRights.Connect))
{
using (ServiceHandle serviceHandle = scm.OpenService(_tempServiceConfig.ServiceName, Advapi32.ServiceAccessRights.AllAccess))
{
serviceHandle.ChangeConfig(_tempServiceConfig);
}
}
}
//Save settings in registry after no error is occured
RegistryManagement.SaveInRegistry(_tempServiceConfig);
DialogResult = true;
Close();
}
catch (Exception ex)
{
MessageBox.Show(
_resManager.GetString("the_service_installation_was_unsuccessful",
CultureInfo.CurrentUICulture) + "\n" + ex.Message, "Error", MessageBoxButton.OK,
MessageBoxImage.Error);
}
}
private static int RunEditReturnExitCode(EditOptions opts)
{
//Check Admin right
if (!DaemonMasterUtils.IsElevated())
{
Console.WriteLine("You must start the program with admin rights.");
return(1);
}
//------------------------
DmServiceDefinition serviceDefinition;
try
{
if (string.IsNullOrWhiteSpace(opts.ServiceName))
{
Console.WriteLine("The given service name is invalid.");
return(-1);
}
string realServiceName = opts.ServiceName;
if (!RegistryManagement.IsDaemonMasterService(realServiceName))
{
realServiceName = "DaemonMaster_" + realServiceName; //Check for the name of the old system TODO: remove later
if (!RegistryManagement.IsDaemonMasterService(realServiceName))
{
Console.WriteLine("Cannot found a DaemonMaster service with the given name.");
return(-1);
}
}
//Load data from registry
serviceDefinition = RegistryManagement.LoadFromRegistry(realServiceName);
}
catch (Exception)
{
Console.WriteLine("Cannot found a service with the given service name."); //"\n" + e.Message + "\n StackTrace: " + e.StackTrace);
return(1);
}
try
{
CheckAndSetCommonArguments(ref serviceDefinition, opts);
//Edit service
using (ServiceControlManager scm = ServiceControlManager.Connect(Advapi32.ServiceControlManagerAccessRights.Connect))
{
using (ServiceHandle service = scm.OpenService(serviceDefinition.ServiceName, Advapi32.ServiceAccessRights.AllAccess))
{
if (service.QueryServiceStatus().currentState != Advapi32.ServiceCurrentState.Stopped)
{
Console.WriteLine("Service is not stopped, please stop it first.");
return(1);
}
service.ChangeConfig(serviceDefinition);
}
}
//Save arguments in registry
RegistryManagement.SaveInRegistry(serviceDefinition);
Console.WriteLine("Successful!");
return(0);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return(1);
}
}