private void OpenServiceItemMessageExecute(OpenEditServiceWindowMessage obj)
{
//// If it's not the view model of this view => return
if (!_viewModel.Equals(obj.Sender))
{
return;
}
//Check if already one window with the same service is opened (from this instance) => when true show and focus it
//var editServiceWindows = Application.Current.Windows.OfType<ServiceEditWindow>();
var editServiceWindows = OwnedWindows.OfType <ServiceEditWindow>();
var addWindow = editServiceWindows.FirstOrDefault(x => x.WindowIdentifier == (obj.ServiceItem?.ServiceName ?? string.Empty));
if (addWindow != default)
{
addWindow.Show();
addWindow.Focus();
return;
}
DmServiceDefinition data = obj.ServiceItem != null?RegistryManagement.LoadFromRegistry(obj.ServiceItem.ServiceName) : null;
//TODO: MVVM also use show later...
var window = new ServiceEditWindow(data)
{
Owner = this,
DataContext = new NewEditViewModel(),
ReadOnlyMode = obj.ReadOnlyMode,
OriginalItem = obj.ServiceItem,
WindowIdentifier = obj.ServiceItem?.ServiceName ?? string.Empty,
WindowStartupLocation = WindowStartupLocation.CenterOwner
};
window.Show();
}
public ServiceEditWindow(DmServiceDefinition daemon)
{
InitializeComponent();
_tempServiceConfig = daemon ?? new DmServiceDefinition(serviceName: null);
//Create a new service when the service name is empty
if (string.IsNullOrWhiteSpace(_tempServiceConfig.ServiceName))
{
_createNewService = true;
}
//Show the information on the UI
LoadServiceInfos();
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
// Constructor + Init //
//////////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes a new instance of the <see cref="DmProcess"/> class.
/// </summary>
/// <param name="serviceDefinition">The service definition.</param>
internal DmProcess(DmServiceDefinition serviceDefinition)
{
_serviceDefinition = serviceDefinition;
//If it's a shortcut get the real binary path and arguments
if (ShellLinkWrapper.IsShortcut(serviceDefinition.BinaryPath))
{
using (var shellLinkWrapper = new ShellLinkWrapper(serviceDefinition.BinaryPath))
{
_serviceDefinition.BinaryPath = shellLinkWrapper.FilePath;
_serviceDefinition.Arguments = FormattingAndJoinArguments(shellLinkWrapper.Arguments, serviceDefinition.Arguments);
}
}
ResetRestartCounter();
}
protected override void OnStart(string[] args)
{
base.OnStart(args);
try
{
//Get the service name
_serviceName = GetServiceName();
//Get data from registry
_serviceDefinition = RegistryManagement.LoadServiceStartInfosFromRegistry(_serviceName);
//--------------------------------------------------------------------
//Setup NLOG for the service
if (_serviceDefinition.UseEventLog)
{
SetupEventLogService();
}
//Request additional time
RequestAdditionalTime(_serviceDefinition.ProcessTimeoutTime + 1000);
//Create a new DmProcess instance with reg data
_dmProcess = new DmProcess(_serviceDefinition);
_dmProcess.MaxRestartsReached += DmProcessOnMaxRestartsReached;
_dmProcess.UpdateProcessPid += DmProcessOnUpdateProcessPid;
//Check if the service should start in a user session or in the service session
string sessionUsername = RegistryManagement.ReadAndClearSessionUsername(_serviceName);
if (string.IsNullOrWhiteSpace(sessionUsername))
{
Logger.Info("Starting the process in service session...");
_dmProcess.StartProcess(null);
}
else
{
Logger.Info("Starting the process in user session...");
_dmProcess.StartProcess(sessionUsername);
}
}
catch (Exception ex)
{
Logger.Error(ex, ex.Message);
Stop();
}
}
private static int RunInstallAndReturnExitCode(InstallOptions opts)
{
//Check Admin right
if (!DaemonMasterUtils.IsElevated())
{
Console.WriteLine("You must start the program with admin rights.");
return(1);
}
//------------------------
if (string.IsNullOrWhiteSpace(opts.ServiceName))
{
Console.WriteLine("The given service name is invalid.");
return(-1);
}
var serviceDefinition = new DmServiceDefinition(opts.ServiceName)
{
BinaryPath = opts.FullPath,
DisplayName = opts.DisplayName
};
try
{
CheckAndSetCommonArguments(ref serviceDefinition, opts);
//Install service
using (ServiceControlManager scm = ServiceControlManager.Connect(Advapi32.ServiceControlManagerAccessRights.CreateService))
{
scm.CreateService(serviceDefinition);
}
//Save arguments in registry
RegistryManagement.SaveInRegistry(serviceDefinition);
Console.WriteLine("Successful!");
return(0);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return(1);
}
}
private void ImportConfiguration()
{
var openFileDialog = new OpenFileDialog
{
InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyComputer),
Filter = "DaemonMaster Config (*.dmdf)|*.dmdf|" +
"All files (*.*)|*.*",
AddExtension = true,
CheckFileExists = true,
CheckPathExists = true,
DereferenceLinks = true,
Multiselect = false
};
try
{
if (openFileDialog.ShowDialog() == true)
{
_createNewService = true;
using (StreamReader streamReader = File.OpenText(openFileDialog.FileName))
using (JsonTextReader jsonTextReader = new JsonTextReader(streamReader))
{
{
var serializer = new JsonSerializer()
{
TypeNameHandling = TypeNameHandling.None,
};
_tempServiceConfig = serializer.Deserialize <DmServiceDefinition>(jsonTextReader);
}
LoadServiceInfos();
}
}
}
catch (Exception ex)
{
MessageBox.Show(_resManager.GetString("cannot_import_daemon") + "\n" + ex.Message, _resManager.GetString("error"), MessageBoxButton.OK, MessageBoxImage.Error);
}
}
private static void CheckAndSetCommonArguments(ref DmServiceDefinition serviceDefinition, CommonEditInstallOptions opts)
{
serviceDefinition.Description = opts.Description ?? serviceDefinition.Description;
serviceDefinition.Arguments = opts.Arguments ?? serviceDefinition.Arguments;
serviceDefinition.LoadOrderGroup = opts.LoadOrderGroup ?? serviceDefinition.LoadOrderGroup;
serviceDefinition.CanInteractWithDesktop = opts.CanInteractWithDesktop ?? serviceDefinition.CanInteractWithDesktop;
serviceDefinition.ProcessMaxRestarts = opts.MaxRestarts ?? serviceDefinition.ProcessMaxRestarts;
serviceDefinition.ProcessTimeoutTime = opts.ProcessTimeoutTime ?? serviceDefinition.ProcessTimeoutTime;
serviceDefinition.ProcessRestartDelay = opts.ProcessRestartDelay ?? serviceDefinition.ProcessRestartDelay;
serviceDefinition.CounterResetTime = opts.CounterResetTime ?? serviceDefinition.CounterResetTime;
serviceDefinition.IsConsoleApplication = opts.ConsoleApplication ?? serviceDefinition.IsConsoleApplication;
serviceDefinition.UseCtrlC = opts.UseCtrlC ?? serviceDefinition.UseCtrlC;
serviceDefinition.Credentials = new ServiceCredentials(opts.Username, opts?.Password?.ConvertStringToSecureString());
if (opts.StartType != null)
{
switch (opts.StartType)
{
case 0:
serviceDefinition.StartType = Advapi32.ServiceStartType.Disabled;
serviceDefinition.DelayedStart = false;
break;
case 1:
serviceDefinition.StartType = Advapi32.ServiceStartType.StartOnDemand;
serviceDefinition.DelayedStart = false;
break;
case 2:
serviceDefinition.StartType = Advapi32.ServiceStartType.AutoStart;
serviceDefinition.DelayedStart = false;
break;
case 4:
serviceDefinition.StartType = Advapi32.ServiceStartType.AutoStart;
serviceDefinition.DelayedStart = true;
break;
default:
throw new ArgumentException("The StartType can only be between 0-4 (0 = Disabled / 1 = Demand start / 2 = Auto start / 4 = Delayed auto start).");
}
}
if (opts.ProcessPriority != null)
{
switch (opts.ProcessPriority)
{
case -2:
serviceDefinition.ProcessPriority = ProcessPriorityClass.Idle;
break;
case -1:
serviceDefinition.ProcessPriority = ProcessPriorityClass.BelowNormal;
break;
case 0:
serviceDefinition.ProcessPriority = ProcessPriorityClass.Normal;
break;
case 1:
serviceDefinition.ProcessPriority = ProcessPriorityClass.AboveNormal;
break;
case 2:
serviceDefinition.ProcessPriority = ProcessPriorityClass.High;
break;
case 3:
serviceDefinition.ProcessPriority = ProcessPriorityClass.RealTime;
break;
default:
throw new ArgumentException("The ProcessPriority can only be between -2<->3 (-2 = Idle / -1 = Below normal / 0 = Normal / 1 = Above normal / 2 = High / 3 = Real time (not recommended to use)).");
}
}
if (serviceDefinition.CanInteractWithDesktop && !DaemonMasterUtils.IsSupportedWindows10VersionForIwd)
{
throw new ArgumentException("CanInteractWithDesktop is not supported in this windows version.");
}
if (serviceDefinition.CanInteractWithDesktop && (!string.IsNullOrWhiteSpace(serviceDefinition.Credentials.Username) || serviceDefinition.Credentials.Password != null))
{
throw new ArgumentException("CanInteractWithDesktop is not supported with custom user.");
}
if ((string.IsNullOrWhiteSpace(serviceDefinition.Credentials.Username) && serviceDefinition.Credentials.Password != null) || (!string.IsNullOrWhiteSpace(serviceDefinition.Credentials.Username) && serviceDefinition.Credentials == null))
{
throw new ArgumentException("Password/username parameter is missing!");
}
//Custom user
//Create new ServiceCredentials instance
if (!string.IsNullOrWhiteSpace(serviceDefinition.Credentials.Username) && serviceDefinition.Credentials.Password != null && !ServiceCredentials.IsVirtualAccount(serviceDefinition.Credentials))
{
//Check if he has the right to start as service
using (LsaPolicyHandle lsaWrapper = LsaPolicyHandle.OpenPolicyHandle())
{
bool hasRightToStartAsService = lsaWrapper.EnumeratePrivileges(serviceDefinition.Credentials.Username).Any(x => x == "SeServiceLogonRight");
if (!hasRightToStartAsService)
{
Console.WriteLine("The user doesn't have the right to start as service. Do you want to give him that right? [Yes/No]");
switch (Console.ReadLine())
{
case "yes":
case "Yes":
case "y":
case "Y":
//Give the account the right to start as service
lsaWrapper.AddPrivilege(serviceDefinition.Credentials.Username, "SeServiceLogonRight");
break;
default:
throw new ArgumentException("Cannot create the service without that right.");
}
}
}
}
}
private void EditDaemon()
{
if (ListViewDaemons.SelectedItem == null)
{
return;
}
var serviceListViewItem = (ServiceListViewItem)ListViewDaemons.SelectedItem;
//Stop service first
using (var serviceController = new ServiceController(serviceListViewItem.ServiceName))
{
if (serviceController.Status != ServiceControllerStatus.Stopped)
{
MessageBoxResult result = MessageBox.Show(_resManager.GetString("you_must_stop_the_service_first"),
_resManager.GetString("information"), MessageBoxButton.YesNo, MessageBoxImage.Information);
if (result == MessageBoxResult.Yes)
{
StopService(serviceListViewItem);
try
{
serviceController.WaitForStatus(ServiceControllerStatus.Stopped, TimeSpan.FromSeconds(10));
}
catch (TimeoutException ex)
{
//TODO: Better message
MessageBox.Show("Cannot stop the service:\n" + ex.Message, _resManager.GetString("error"), MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
}
else
{
return;
}
}
}
try
{
//Open service edit window with the data from registry
var serviceEditWindow = new ServiceEditWindow(RegistryManagement.LoadServiceStartInfosFromRegistry(serviceListViewItem.ServiceName));
//stops until windows has been closed
bool?dialogResult = serviceEditWindow.ShowDialog();
//Check result
if (dialogResult.HasValue && dialogResult.Value)
{
DmServiceDefinition serviceDefinition = serviceEditWindow.GetServiceStartInfo();
if (string.Equals(serviceDefinition.ServiceName, serviceListViewItem.ServiceName))
{
//Update serviceListViewItem
_processCollection[_processCollection.IndexOf(serviceListViewItem)] = ServiceListViewItem.CreateFromServiceDefinition(serviceDefinition);
}
else
{
//Create new daemon (Import as happend with a diffrent service name => create new service with that name)
_processCollection.Add(ServiceListViewItem.CreateFromServiceDefinition(serviceDefinition));
}
}
}
catch (Exception ex)
{
MessageBox.Show(_resManager.GetString("cannot_load_data_from_registry") + "\n" + ex.Message, _resManager.GetString("error"), MessageBoxButton.OK, MessageBoxImage.Error);
}
}
