Example #1
0
        public Service[] GetDependentServices(Service service)
        {
            var servicePtr = ADVANCED_API.OpenService(
                _managerPtr, service.Name, SERVICE_ACCESS.SERVICE_ENUMERATE_DEPENDENTS);

            if (servicePtr == IntPtr.Zero)
            {
                var error = Marshal.GetLastWin32Error();
                throw new Win32Exception(error);
            }
            var enumerated = ADVANCED_API.EnumDependentServices(
                servicePtr,
                SERVICE_ACTIVE_STATE.SERVICE_STATE_ALL,
                IntPtr.Zero, 0,
                out var bytesNeeded,
                out _);

            if (enumerated)
            {
                return(Array.Empty <Service>());
            }
            else
            {
                var error = Marshal.GetLastWin32Error();
                if (error != ERROR.ERROR_MORE_DATA)
                {
                    throw new Win32Exception(error);
                }
            }
            var memoryPtr = Marshal.AllocHGlobal(bytesNeeded);

            try
            {
                enumerated = ADVANCED_API.EnumDependentServices(
                    servicePtr,
                    SERVICE_ACTIVE_STATE.SERVICE_STATE_ALL,
                    memoryPtr, bytesNeeded,
                    out bytesNeeded,
                    out var servicesReturned);
                if (!enumerated)
                {
                    var error = Marshal.GetLastWin32Error();
                    throw new Win32Exception(error);
                }
                var services   = new Service[servicesReturned];
                var statusSize = Marshal.SizeOf <ENUM_SERVICE_STATUS>();
                for (int i = 0; i < servicesReturned; i++)
                {
                    var statusPtr = memoryPtr + i * statusSize;
                    var status    = Marshal.PtrToStructure <ENUM_SERVICE_STATUS>(statusPtr);
                    services[i] = new Service(status);
                }
                return(services);
            }
            finally
            {
                Marshal.FreeHGlobal(memoryPtr);
            }
        }
Example #2
0
        public void Start(Service service, string[] args)
        {
            var servicePtr = ADVANCED_API.OpenService(_managerPtr, service.Name, SERVICE_ACCESS.SERVICE_START);

            if (servicePtr == IntPtr.Zero)
            {
                var error = Marshal.GetLastWin32Error();
                throw new Win32Exception(error);
            }
            var started = ADVANCED_API.StartService(servicePtr, args.Length, args);
            var closed  = ADVANCED_API.CloseServiceHandle(servicePtr);

            if (!started || !closed)
            {
                var error = Marshal.GetLastWin32Error();
                throw new Win32Exception(error);
            }
        }
Example #3
0
        public void Delete(Service service)
        {
            var servicePtr = ADVANCED_API.OpenService(_managerPtr, service.Name, SERVICE_ACCESS.DELETE);

            if (servicePtr == IntPtr.Zero)
            {
                var error = Marshal.GetLastWin32Error();
                throw new Win32Exception(error);
            }
            var deleted = ADVANCED_API.DeleteService(servicePtr);
            var closed  = ADVANCED_API.CloseServiceHandle(servicePtr);

            if (!deleted || !closed)
            {
                var error = Marshal.GetLastWin32Error();
                throw new Win32Exception(error);
            }
        }
Example #4
0
        public void Stop(Service service)
        {
            var servicePtr = ADVANCED_API.OpenService(_managerPtr, service.Name, SERVICE_ACCESS.SERVICE_STOP);

            if (servicePtr == IntPtr.Zero)
            {
                var error = Marshal.GetLastWin32Error();
                throw new Win32Exception(error);
            }
            //var size = Marshal.SizeOf<SERVICE_STATUS>();
            //var statusPtr = Marshal.AllocHGlobal(size);
            //var stopped = Advapi32.ControlService(servicePtr, SERVICE_CONTROL.SERVICE_CONTROL_STOP, statusPtr);
            //var status = Marshal.PtrToStructure<SERVICE_STATUS>(statusPtr);
            //Marshal.FreeHGlobal(statusPtr);
            var stopped = ADVANCED_API.ControlService(servicePtr, SERVICE_CONTROL.SERVICE_CONTROL_STOP, out _);
            var closed  = ADVANCED_API.CloseServiceHandle(servicePtr);

            if (!stopped || !closed)
            {
                var error = Marshal.GetLastWin32Error();
                throw new Win32Exception(error);
            }
        }