学步园

class 设置服务恢复选项
    {
        public static void Main(string[] args)
        {
            ServiceRecovery.UpdateServiceConfig("DEMO");
            Console.WriteLine("ok");
        }
    }

    class ServiceRecovery
    {
        #region NativeMethod
        
        [DllImport("advapi32.dll", SetLastError = true, CharSet = CharSet.Auto)]
        [return: MarshalAs(UnmanagedType.Bool)]
        public static extern bool ChangeServiceConfig2(IntPtr hService, int dwInfoLevel, IntPtr lpInfo);

        [DllImport("advapi32.dll", SetLastError = true, CharSet = CharSet.Auto)]
        public static extern IntPtr OpenSCManager(string MachineName, string DatabaseName, uint DesiredAcces);

        [DllImport("advapi32.dll", SetLastError = true, CharSet = CharSet.Auto)]
        public static extern IntPtr OpenService(IntPtr scHandle, string serviceName, int DesiredAccess);

        [DllImport("advapi32.dll", SetLastError = true, CharSet = CharSet.Auto)]
        public static extern bool CloseServiceHandle(IntPtr hSCObject);

        [DllImport("advapi32.dll")]
        public static extern IntPtr LockServiceDatabase(IntPtr hSCManager);

        [DllImport("advapi32.dll")]
        public static extern bool UnlockServiceDatabase(IntPtr hSCManager);

        [DllImport("kernel32.dll")]
        public static extern int GetLastError();

        [DllImport("advapi32.dll", EntryPoint = "ChangeServiceConfig2")]
        public static extern bool ChangeServiceFailureActions(IntPtr hService, int dwInfoLevel, [MarshalAs(UnmanagedType.Struct)] ref SERVICE_FAILURE_ACTIONS lpInfo);

        [DllImport("advapi32.dll")]
        public static extern bool AdjustTokenPrivileges(IntPtr TokenHandle, bool DisableAllPrivileges, [MarshalAs(UnmanagedType.Struct)] ref TOKEN_PRIVILEGES NewState, int BufferLength, IntPtr PreviousState, ref int ReturnLength);

        [DllImport("advapi32.dll")]
        public static extern bool LookupPrivilegeValue(string lpSystemName, string lpName, ref long lpLuid);

        [DllImport("advapi32.dll")]
        public static extern bool OpenProcessToken(IntPtr ProcessHandle, int DesiredAccess, ref IntPtr TokenHandle);

        [DllImport("kernel32.dll")]
        public static extern IntPtr GetCurrentProcess();

        [DllImport("kernel32.dll")]
        public static extern bool CloseHandle(IntPtr hndl);
        
        #endregion

        private const int TOKEN_ADJUST_PRIVILEGES = 32;
        private const int TOKEN_QUERY = 8;
        private const string SE_SHUTDOWN_NAME = "SeShutdownPrivilege";
        private const int SE_PRIVILEGE_ENABLED = 2;

        [StructLayout(LayoutKind.Sequential, Pack = 1)]
        public struct TOKEN_PRIVILEGES
        {
            public int PrivilegeCount;
            public LUID_AND_ATTRIBUTES Privileges;
        }
        [StructLayout(LayoutKind.Sequential)]
        public struct LUID_AND_ATTRIBUTES
        {
            public long Luid;
            public int Attributes;
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct SERVICE_FAILURE_ACTIONS
        {
            /// <summary>
            /// 在此时间之后重置失败计数
            /// </summary>
            public int dwResetPeriod;
            public string lpRebootMsg;
            public string lpCommand;
            public int cActions;
            public int lpsaActions;
        }

        private const int SC_MANAGER_ALL_ACCESS = 0xF003F;
        private const int SERVICE_ALL_ACCESS = 0xF01FF;
        private const int SERVICE_CONFIG_DESCRIPTION = 0x1;
        private const int SERVICE_CONFIG_FAILURE_ACTIONS = 0x2;
        private const int ERROR_ACCESS_DENIED = 5;
        
        static string logMsgBase = "";
        static string ServiceName = "";

        public static void UpdateServiceConfig(string serviceName)
        {
            logMsgBase = "Windows 服务" + ServiceName + ":";
            ServiceName = serviceName;
            var FailureActions = new ArrayList();
            
            //第一次失败
            FailureActions.Add(new FailureAction(RecoverAction.Restart, 0));
            //第二次失败
            FailureActions.Add(new FailureAction(RecoverAction.None, 0));
            //后续失败
            FailureActions.Add(new FailureAction(RecoverAction.Reboot, 0));

            int numActions = FailureActions.Count;

            IntPtr scmHndl = IntPtr.Zero;
            IntPtr svcHndl = IntPtr.Zero;
            IntPtr tmpBuf = IntPtr.Zero;
            IntPtr svcLock = IntPtr.Zero;
            
            bool rslt = false;
            try
            {
                scmHndl = OpenSCManager(null, null, SC_MANAGER_ALL_ACCESS);
                if (scmHndl.ToInt32() <= 0)
                {
                    LogInstallMessage(EventLogEntryType.Error, logMsgBase + "打开服务控制管理器失败");
                    return;
                }
                svcLock = LockServiceDatabase(scmHndl);
                if (svcLock.ToInt32() <= 0)
                {

                    LogInstallMessage(EventLogEntryType.Error, logMsgBase + "无法锁定服务数据库进行写入");
                    return;
                }
                svcHndl = OpenService(scmHndl, ServiceName, SERVICE_ALL_ACCESS);

                if (svcHndl.ToInt32() <= 0)
                {
                    LogInstallMessage(EventLogEntryType.Information, logMsgBase + "无法打开服务");
                    return;
                }
                
                    int[] actions = new int[numActions * 2];
                    int currInd = 0;
                    bool needShutdownPrivilege = false;
                    foreach (FailureAction fa in FailureActions)
                    {
                        actions[currInd] = (int)fa.Type;
                        actions[++currInd] = fa.Delay;
                        currInd++;
                        if (fa.Type == RecoverAction.Reboot)
                        {
                            needShutdownPrivilege = true;
                        }
                    }

                    if (needShutdownPrivilege)
                    {
                        rslt = GrandShutdownPrivilege();
                        if (!rslt) return;
                    }

                    tmpBuf = Marshal.AllocHGlobal(numActions * 8);
                    Marshal.Copy(actions, 0, tmpBuf, numActions * 2);
                    SERVICE_FAILURE_ACTIONS sfa = new SERVICE_FAILURE_ACTIONS();

                    sfa.cActions = numActions;
                    sfa.dwResetPeriod = 0;
                    sfa.lpCommand = "";
                    sfa.lpRebootMsg = "";
                    sfa.lpsaActions = tmpBuf.ToInt32();
                
                    rslt = ChangeServiceFailureActions(svcHndl, SERVICE_CONFIG_FAILURE_ACTIONS, ref sfa);
                    if (!rslt)
                    {
                        int err = GetLastError();
                        if (err == ERROR_ACCESS_DENIED)
                        {
                            throw new Exception(logMsgBase + "配置失败时恢复的操作失败");
                        }
                    }
                    Marshal.FreeHGlobal(tmpBuf); tmpBuf = IntPtr.Zero;
                    LogInstallMessage(EventLogEntryType.Information, logMsgBase + "已成功配置失败时恢复的操作");

            }
            catch (Exception ex)
            {
                LogInstallMessage(EventLogEntryType.Error, ex.Message);
            }
            finally
            {
                if (scmHndl != IntPtr.Zero)
                {
                    if (svcLock != IntPtr.Zero)
                    {
                        UnlockServiceDatabase(svcLock);
                        svcLock = IntPtr.Zero;
                    }
                    CloseServiceHandle(scmHndl);
                    scmHndl = IntPtr.Zero;
                }
                if (svcHndl != IntPtr.Zero)
                {
                    CloseServiceHandle(svcHndl);
                    svcHndl = IntPtr.Zero;
                }
                if (tmpBuf != IntPtr.Zero)
                {
                    Marshal.FreeHGlobal(tmpBuf);
                    tmpBuf = IntPtr.Zero;
                }
            }

        }
        
        static bool GrandShutdownPrivilege()
        {
            bool retRslt = false;
            IntPtr hToken = IntPtr.Zero;
            IntPtr myProc = IntPtr.Zero;
            TOKEN_PRIVILEGES tkp = new TOKEN_PRIVILEGES();
            long Luid = 0;
            int retLen = 0;

            try
            {

                myProc = GetCurrentProcess();
                bool rslt = OpenProcessToken(myProc, TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, ref hToken);
                if (!rslt) return retRslt;

                LookupPrivilegeValue(null, SE_SHUTDOWN_NAME, ref Luid);

                tkp.PrivilegeCount = 1;
                tkp.Privileges.Luid = Luid;
                tkp.Privileges.Attributes = SE_PRIVILEGE_ENABLED;

                rslt = AdjustTokenPrivileges(hToken, false, ref tkp, 0, IntPtr.Zero, ref retLen);

                if (GetLastError() != 0)
                {
                    throw new Exception("无法授予关机特权");
                }
                retRslt = true;
            }
            catch (Exception ex)
            {
                LogInstallMessage(EventLogEntryType.Error, logMsgBase + ex.Message);
            }
            finally
            {
                if (hToken != IntPtr.Zero)
                {
                    CloseHandle(hToken);
                }
            }
            return retRslt;
        }
        
        static void LogInstallMessage(EventLogEntryType logLevel, string msg)
        {
            try
            {
                EventLog.WriteEntry(ServiceName, msg, logLevel);
            }
            catch
            {
                
            }
        }

        enum RecoverAction
        {
            /// <summary>
            /// 无操作
            /// </summary>
            None = 0, 
            /// <summary>
            /// 重新启动服务
            /// </summary>
            Restart = 1, 
            /// <summary>
            /// 重启计算机
            /// </summary>
            Reboot = 2, 
            /// <summary>
            /// 运行一个程序
            /// </summary>
            RunCommand = 3
        }

        class FailureAction
        {
            private RecoverAction type = RecoverAction.None;
            /// <summary>
            /// 在此时间之后重新启动服务
            /// </summary>
            private int delay = 0;
            public FailureAction()
            {

            }
            public FailureAction(RecoverAction actionType, int actionDelay)
            {
                this.type = actionType;
                this.delay = actionDelay;
            }

            public RecoverAction Type
            {
                get { return type; }
                set { type = value; }
            }
            /// <summary>
            /// 在此时间之后重新启动服务
            /// </summary>
            public int Delay
            {
                get { return delay; }
                set { delay = value; }
            }

        }
    }