public static void ErrorExit(ILog log, IntPtr serviceHandle, UInt32 serviceSpecificExitCode)
 {
     var status = new SERVICE_STATUS
     {
         dwServiceType             = SERVICE_TYPES.SERVICE_WIN32_OWN_PROCESS,
         dwCurrentState            = SERVICE_STATE.SERVICE_STOPPED,
         dwControlsAccepted        = 0,
         dwWin32ExitCode           = ERROR_SERVICE_SPECIFIC_ERROR,
         dwServiceSpecificExitCode = serviceSpecificExitCode,
         dwCheckPoint              = 0,
         dwWaitHint                = 5000,
     };
     bool serviceStatusRV = SetServiceStatus(serviceHandle, ref status);
     log.Debug("SetServiceStatus rv: {0}", serviceStatusRV);
 }

 public static extern int ControlService( int hService,
     uint dwControl,
     ref SERVICE_STATUS lpServiceStatus);

 public static extern bool SetServiceStatus(IntPtr hServiceStatus, ref SERVICE_STATUS lpServiceStatus);

 public static extern bool ControlService(SafeServiceHandle hService, ServiceControl dwControl, ref SERVICE_STATUS lpServiceStatus);

 private static void StopService(IntPtr service)
 {
     SERVICE_STATUS status = new SERVICE_STATUS();
     ControlService(service, ServiceControl.Stop, status);
     var changedStatus = WaitForServiceStatus(service, ServiceState.StopPending, ServiceState.Stopped);
     if (!changedStatus)
         throw new ApplicationException("Unable to stop service");
 }

 private static extern int QueryServiceStatus(IntPtr hService, SERVICE_STATUS lpServiceStatus);

 private static extern int ControlService(IntPtr hService, ServiceControl dwControl, SERVICE_STATUS lpServiceStatus);

 private static bool StartService(IntPtr service)
 {
     SERVICE_STATUS status = new SERVICE_STATUS();
     StartService(service, 0, 0);
     var changedStatus = WaitForServiceStatus(service, ServiceState.StartPending, ServiceState.Running);
     if (!changedStatus)
         return false;
     return true;
 }

 public static extern bool QueryServiceStatus(
     int Service, 
     ref SERVICE_STATUS ServiceStatus
     );

 public static extern bool ControlService(
     int Service,
     SERVICE_CONTROL Control, 
     ref SERVICE_STATUS ServiceStatus
     );

		private static extern bool ControlService (
			IntPtr hService,
			SERVICE_CONTROL_TYPE dwControl,
			ref SERVICE_STATUS lpServiceStatus);

		public override void Stop ()
		{
			string serviceName = ServiceController.ServiceName;
			string machineName = ServiceController.MachineName;
			IntPtr scHandle = IntPtr.Zero;
			IntPtr svcHandle = IntPtr.Zero;

			try {
				scHandle = OpenServiceControlManager (machineName,
					SERVICE_MANAGER_RIGHTS.SC_MANAGER_CONNECT);

				svcHandle = OpenService (scHandle, serviceName, SERVICE_RIGHTS.SERVICE_STOP);
				if (svcHandle == IntPtr.Zero)
					throw CreateCannotOpenServiceException (serviceName,
						machineName);

				SERVICE_STATUS status = new SERVICE_STATUS ();
				if (!ControlService (svcHandle, SERVICE_CONTROL_TYPE.SERVICE_CONTROL_STOP, ref status))
					throw new InvalidOperationException (string.Format (
						CultureInfo.CurrentCulture, "Cannot stop {0} service"
						+ " on computer '{1}'.", serviceName, machineName),
						new Win32Exception ());
			} finally {
				if (svcHandle != IntPtr.Zero)
					CloseServiceHandle (svcHandle);
				if (scHandle != IntPtr.Zero)
					CloseServiceHandle (scHandle);
			}
		}

		public override void ExecuteCommand (int command)
		{
			string serviceName = ServiceController.ServiceName;
			string machineName = ServiceController.MachineName;
			IntPtr scHandle = IntPtr.Zero;
			IntPtr svcHandle = IntPtr.Zero;

			try {
				scHandle = OpenServiceControlManager (machineName,
					SERVICE_MANAGER_RIGHTS.SC_MANAGER_CONNECT);

				// MSDN: the hService handle must have the SERVICE_USER_DEFINED_CONTROL
				// access right
				svcHandle = OpenService (scHandle, serviceName, SERVICE_RIGHTS.SERVICE_USER_DEFINED_CONTROL);
				if (svcHandle == IntPtr.Zero)
					throw CreateCannotOpenServiceException (serviceName,
						machineName);

				SERVICE_STATUS status = new SERVICE_STATUS ();
				if (!ControlService (svcHandle, (SERVICE_CONTROL_TYPE) command, ref status))
					throw new InvalidOperationException (string.Format (
						CultureInfo.CurrentCulture, "Cannot control {0} service"
						+ " on computer '{1}'.", serviceName, machineName),
						new Win32Exception ());
			} finally {
				if (svcHandle != IntPtr.Zero)
					CloseServiceHandle (svcHandle);
				if (scHandle != IntPtr.Zero)
					CloseServiceHandle (scHandle);
			}
		}

 public static extern int SetServiceStatus( int hServiceStatus,
     ref SERVICE_STATUS lpServiceStatus);

 public static extern int QueryServiceStatus( int hService,
     ref SERVICE_STATUS lpServiceStatus);

 private void PauseService(IntPtr service, bool wait = true)
 {
     if (this.GetServiceStatus(service) != ServiceState.Running)
         throw new ServiceOperationException(this._serviceName, "Pause", "Cannot pause a service which isn't already running");
     var status = new SERVICE_STATUS();
     ControlService(service, ServiceControl.Pause, status);
     if (wait)
     {
         var changedStatus = this.WaitForServiceStatus(service, ServiceState.PausePending, ServiceState.Paused);
         if (!changedStatus)
             throw new ServiceOperationException(this._serviceName, "Pause", "Unable to pause service");
     }
 }

        private void StopService(IntPtr service, bool wait = true)
        {
            if (this.GetServiceStatus(service) != ServiceState.Running)
                return;
            var process = Process.GetProcessById(this.ServicePID);
            SERVICE_STATUS status = new SERVICE_STATUS();
            ControlService(service, ServiceControl.Stop, status);
            const string op = "Stop";
            if (wait)
            {
                var changedStatus = this.WaitForServiceStatus(service, ServiceState.StopPending, ServiceState.Stopped);
                if (!changedStatus)
                    throw new ServiceOperationException(this._serviceName, op, "Unable to stop service");
                var waitLevel = 0;
                try
                {
                    if (!process.HasExited)
                    {
                        waitLevel++;
                        if (!process.WaitForExit((int)this._serviceStopTimeoutMS))
                        {
                            waitLevel++;
                            process.Kill();
                        }
                    }
                }
                catch (Exception ex)
                {
                    switch (waitLevel)
                    {
                        case 0:
                            throw new ServiceOperationException(this._serviceName, op,
                                GenerateStopExceptionMessageWith("but threw errors when interrogating process state", ex));
                        case 1:
                            throw new ServiceOperationException(this._serviceName, op,
                                GenerateStopExceptionMessageWith("and we got an error whilst waiting 10 seconds for graceful exit", ex));
                        case 2:
                            throw new ServiceOperationException(this._serviceName, op,
                                GenerateStopExceptionMessageWith("and we got an error after trying to kill it when it didn't gracefully exit within 10 seconds", ex));

                    }
                }
            }
        }

 public static extern unsafe bool SetServiceStatus(IntPtr serviceStatusHandle, SERVICE_STATUS* status);

 private static bool StopService(IntPtr service)
 {
     SERVICE_STATUS status = new SERVICE_STATUS();
     ControlService(service, ServiceControl.Stop, status);
     var changedStatus = WaitForServiceStatus(service, ServiceState.StopPending, ServiceState.Stopped);
     if (!changedStatus)
         return false;
     return true;
 }

 /// <summary>
 /// Stars the provided windows service
 /// </summary>
 /// <param name="hService">The handle to the windows service</param>
 private static void StartService(IntPtr hService)
 {
     SERVICE_STATUS status = new SERVICE_STATUS();
     StartService(hService, 0, 0);
     WaitForServiceStatus(hService, ServiceState.Starting, ServiceState.Run);
 }