Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:27
📄 config.go // Copyright 2012 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build windows package mgr import ( "syscall" "unsafe" "golang.org/x/sys/windows" ) const ( // Service start types. StartManual = windows.SERVICE_DEMAND_START // the service must be started manually StartAutomatic = windows.SERVICE_AUTO_START // the service will start by itself whenever the computer reboots StartDisabled = windows.SERVICE_DISABLED // the service cannot be started // The severity of the error, and action taken, // if this service fails to start. ErrorCritical = windows.SERVICE_ERROR_CRITICAL ErrorIgnore = windows.SERVICE_ERROR_IGNORE ErrorNormal = windows.SERVICE_ERROR_NORMAL ErrorSevere = windows.SERVICE_ERROR_SEVERE ) // TODO(brainman): Password is not returned by windows.QueryServiceConfig, not sure how to get it. type Config struct { ServiceType uint32 StartType uint32 ErrorControl uint32 BinaryPathName string // fully qualified path to the service binary file, can also include arguments for an auto-start service LoadOrderGroup string TagId uint32 Dependencies []string ServiceStartName string // name of the account under which the service should run DisplayName string Password string Description string SidType uint32 // one of SERVICE_SID_TYPE, the type of sid to use for the service DelayedAutoStart bool // the service is started after other auto-start services are started plus a short delay } func toStringSlice(ps uint16) []string { r := make([]string, 0) p := unsafe.Pointer(ps) for { s := windows.UTF16PtrToString((uint16)(p)) if len(s) == 0 { break } r = append(r, s) offset := unsafe.Sizeof(uint16(0)) * (uintptr)(len(s)+1) p = unsafe.Pointer(uintptr(p) + offset) } return r } // Config retrieves service s configuration parameters. func (s Service) Config() (Config, error) { var p windows.QUERY_SERVICE_CONFIG n := uint32(1024) for { b := make([]byte, n) p = (windows.QUERY_SERVICE_CONFIG)(unsafe.Pointer(&b[0])) err := windows.QueryServiceConfig(s.Handle, p, n, &n) if err == nil { break } if err.(syscall.Errno) != syscall.ERROR_INSUFFICIENT_BUFFER { return Config{}, err } if n <= uint32(len(b)) { return Config{}, err } } b, err := s.queryServiceConfig2(windows.SERVICE_CONFIG_DESCRIPTION) if err != nil { return Config{}, err } p2 := (windows.SERVICE_DESCRIPTION)(unsafe.Pointer(&b[0])) b, err = s.queryServiceConfig2(windows.SERVICE_CONFIG_DELAYED_AUTO_START_INFO) if err != nil { return Config{}, err } p3 := (windows.SERVICE_DELAYED_AUTO_START_INFO)(unsafe.Pointer(&b[0])) delayedStart := false if p3.IsDelayedAutoStartUp != 0 { delayedStart = true } b, err = s.queryServiceConfig2(windows.SERVICE_CONFIG_SERVICE_SID_INFO) if err != nil { return Config{}, err } sidType := (uint32)(unsafe.Pointer(&b[0])) return Config{ ServiceType: p.ServiceType, StartType: p.StartType, ErrorControl: p.ErrorControl, BinaryPathName: windows.UTF16PtrToString(p.BinaryPathName), LoadOrderGroup: windows.UTF16PtrToString(p.LoadOrderGroup), TagId: p.TagId, Dependencies: toStringSlice(p.Dependencies), ServiceStartName: windows.UTF16PtrToString(p.ServiceStartName), DisplayName: windows.UTF16PtrToString(p.DisplayName), Description: windows.UTF16PtrToString(p2.Description), DelayedAutoStart: delayedStart, SidType: sidType, }, nil } func updateDescription(handle windows.Handle, desc string) error { d := windows.SERVICE_DESCRIPTION{Description: toPtr(desc)} return windows.ChangeServiceConfig2(handle, windows.SERVICE_CONFIG_DESCRIPTION, (byte)(unsafe.Pointer(&d))) } func updateSidType(handle windows.Handle, sidType uint32) error { return windows.ChangeServiceConfig2(handle, windows.SERVICE_CONFIG_SERVICE_SID_INFO, (byte)(unsafe.Pointer(&sidType))) } func updateStartUp(handle windows.Handle, isDelayed bool) error { var d windows.SERVICE_DELAYED_AUTO_START_INFO if isDelayed { d.IsDelayedAutoStartUp = 1 } return windows.ChangeServiceConfig2(handle, windows.SERVICE_CONFIG_DELAYED_AUTO_START_INFO, (byte)(unsafe.Pointer(&d))) } // UpdateConfig updates service s configuration parameters. func (s Service) UpdateConfig(c Config) error { err := windows.ChangeServiceConfig(s.Handle, c.ServiceType, c.StartType, c.ErrorControl, toPtr(c.BinaryPathName), toPtr(c.LoadOrderGroup), nil, toStringBlock(c.Dependencies), toPtr(c.ServiceStartName), toPtr(c.Password), toPtr(c.DisplayName)) if err != nil { return err } err = updateSidType(s.Handle, c.SidType) if err != nil { return err } err = updateStartUp(s.Handle, c.DelayedAutoStart) if err != nil { return err } return updateDescription(s.Handle, c.Description) } // queryServiceConfig2 calls Windows QueryServiceConfig2 with infoLevel parameter and returns retrieved service configuration information. func (s Service) queryServiceConfig2(infoLevel uint32) ([]byte, error) { n := uint32(1024) for { b := make([]byte, n) err := windows.QueryServiceConfig2(s.Handle, infoLevel, &b[0], n, &n) if err == nil { return b, nil } if err.(syscall.Errno) != syscall.ERROR_INSUFFICIENT_BUFFER { return nil, err } if n <= uint32(len(b)) { return nil, err } } }	5.34 KB	2025-05-25 12:27
📄 mgr.go // Copyright 2012 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build windows // Package mgr can be used to manage Windows service programs. // It can be used to install and remove them. It can also start, // stop and pause them. The package can query / change current // service state and config parameters. package mgr import ( "syscall" "time" "unicode/utf16" "unsafe" "golang.org/x/sys/windows" ) // Mgr is used to manage Windows service. type Mgr struct { Handle windows.Handle } // Connect establishes a connection to the service control manager. func Connect() (Mgr, error) { return ConnectRemote("") } // ConnectRemote establishes a connection to the // service control manager on computer named host. func ConnectRemote(host string) (Mgr, error) { var s uint16 if host != "" { s = syscall.StringToUTF16Ptr(host) } h, err := windows.OpenSCManager(s, nil, windows.SC_MANAGER_ALL_ACCESS) if err != nil { return nil, err } return &Mgr{Handle: h}, nil } // Disconnect closes connection to the service control manager m. func (m Mgr) Disconnect() error { return windows.CloseServiceHandle(m.Handle) } type LockStatus struct { IsLocked bool // Whether the SCM has been locked. Age time.Duration // For how long the SCM has been locked. Owner string // The name of the user who has locked the SCM. } // LockStatus returns whether the service control manager is locked by // the system, for how long, and by whom. A locked SCM indicates that // most service actions will block until the system unlocks the SCM. func (m Mgr) LockStatus() (LockStatus, error) { bytesNeeded := uint32(unsafe.Sizeof(windows.QUERY_SERVICE_LOCK_STATUS{}) + 1024) for { bytes := make([]byte, bytesNeeded) lockStatus := (windows.QUERY_SERVICE_LOCK_STATUS)(unsafe.Pointer(&bytes[0])) err := windows.QueryServiceLockStatus(m.Handle, lockStatus, uint32(len(bytes)), &bytesNeeded) if err == windows.ERROR_INSUFFICIENT_BUFFER && bytesNeeded >= uint32(unsafe.Sizeof(windows.QUERY_SERVICE_LOCK_STATUS{})) { continue } if err != nil { return nil, err } status := &LockStatus{ IsLocked: lockStatus.IsLocked != 0, Age: time.Duration(lockStatus.LockDuration) time.Second, Owner: windows.UTF16PtrToString(lockStatus.LockOwner), } return status, nil } } func toPtr(s string) uint16 { if len(s) == 0 { return nil } return syscall.StringToUTF16Ptr(s) } // toStringBlock terminates strings in ss with 0, and then // concatenates them together. It also adds extra 0 at the end. func toStringBlock(ss []string) uint16 { if len(ss) == 0 { return nil } t := "" for _, s := range ss { if s != "" { t += s + "\x00" } } if t == "" { return nil } t += "\x00" return &utf16.Encode([]rune(t))[0] } // CreateService installs new service name on the system. // The service will be executed by running exepath binary. // Use config c to specify service parameters. // Any args will be passed as command-line arguments when // the service is started; these arguments are distinct from // the arguments passed to Service.Start or via the "Start // parameters" field in the service's Properties dialog box. func (m Mgr) CreateService(name, exepath string, c Config, args ...string) (Service, error) { if c.StartType == 0 { c.StartType = StartManual } if c.ServiceType == 0 { c.ServiceType = windows.SERVICE_WIN32_OWN_PROCESS } s := syscall.EscapeArg(exepath) for _, v := range args { s += " " + syscall.EscapeArg(v) } h, err := windows.CreateService(m.Handle, toPtr(name), toPtr(c.DisplayName), windows.SERVICE_ALL_ACCESS, c.ServiceType, c.StartType, c.ErrorControl, toPtr(s), toPtr(c.LoadOrderGroup), nil, toStringBlock(c.Dependencies), toPtr(c.ServiceStartName), toPtr(c.Password)) if err != nil { return nil, err } if c.SidType != windows.SERVICE_SID_TYPE_NONE { err = updateSidType(h, c.SidType) if err != nil { windows.DeleteService(h) windows.CloseServiceHandle(h) return nil, err } } if c.Description != "" { err = updateDescription(h, c.Description) if err != nil { windows.DeleteService(h) windows.CloseServiceHandle(h) return nil, err } } if c.DelayedAutoStart { err = updateStartUp(h, c.DelayedAutoStart) if err != nil { windows.DeleteService(h) windows.CloseServiceHandle(h) return nil, err } } return &Service{Name: name, Handle: h}, nil } // OpenService retrieves access to service name, so it can // be interrogated and controlled. func (m Mgr) OpenService(name string) (Service, error) { h, err := windows.OpenService(m.Handle, syscall.StringToUTF16Ptr(name), windows.SERVICE_ALL_ACCESS) if err != nil { return nil, err } return &Service{Name: name, Handle: h}, nil } // ListServices enumerates services in the specified // service control manager database m. // If the caller does not have the SERVICE_QUERY_STATUS // access right to a service, the service is silently // omitted from the list of services returned. func (m Mgr) ListServices() ([]string, error) { var err error var bytesNeeded, servicesReturned uint32 var buf []byte for { var p byte if len(buf) > 0 { p = &buf[0] } err = windows.EnumServicesStatusEx(m.Handle, windows.SC_ENUM_PROCESS_INFO, windows.SERVICE_WIN32, windows.SERVICE_STATE_ALL, p, uint32(len(buf)), &bytesNeeded, &servicesReturned, nil, nil) if err == nil { break } if err != syscall.ERROR_MORE_DATA { return nil, err } if bytesNeeded <= uint32(len(buf)) { return nil, err } buf = make([]byte, bytesNeeded) } if servicesReturned == 0 { return nil, nil } services := unsafe.Slice((*windows.ENUM_SERVICE_STATUS_PROCESS)(unsafe.Pointer(&buf[0])), int(servicesReturned)) var names []string for _, s := range services { name := windows.UTF16PtrToString(s.ServiceName) names = append(names, name) } return names, nil }	5.85 KB	2025-05-25 12:27
📄 mgr_test.go // Copyright 2012 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build windows package mgr_test import ( "fmt" "os" "path/filepath" "sort" "strings" "syscall" "testing" "time" "golang.org/x/sys/windows" "golang.org/x/sys/windows/svc" "golang.org/x/sys/windows/svc/mgr" ) func TestOpenLanManServer(t testing.T) { m, err := mgr.Connect() if err != nil { if errno, ok := err.(syscall.Errno); ok && errno == syscall.ERROR_ACCESS_DENIED { t.Skip("Skipping test: we don't have rights to manage services.") } t.Fatalf("SCM connection failed: %s", err) } defer m.Disconnect() s, err := m.OpenService("LanmanServer") if err != nil { t.Fatalf("OpenService(lanmanserver) failed: %s", err) } defer s.Close() _, err = s.Config() if err != nil { t.Fatalf("Config failed: %s", err) } } func install(t testing.T, m mgr.Mgr, name, exepath string, c mgr.Config) { // Sometimes it takes a while for the service to get // removed after previous test run. for i := 0; ; i++ { s, err := m.OpenService(name) if err != nil { break } s.Close() if i > 10 { t.Fatalf("service %s already exists", name) } time.Sleep(300 time.Millisecond) } s, err := m.CreateService(name, exepath, c) if err != nil { t.Fatalf("CreateService(%s) failed: %v", name, err) } defer s.Close() } func depString(d []string) string { if len(d) == 0 { return "" } for i := range d { d[i] = strings.ToLower(d[i]) } ss := sort.StringSlice(d) ss.Sort() return strings.Join([]string(ss), " ") } func testConfig(t testing.T, s mgr.Service, should mgr.Config) mgr.Config { is, err := s.Config() if err != nil { t.Fatalf("Config failed: %s", err) } if should.DelayedAutoStart != is.DelayedAutoStart { t.Fatalf("config mismatch: DelayedAutoStart is %v, but should have %v", is.DelayedAutoStart, should.DelayedAutoStart) } if should.DisplayName != is.DisplayName { t.Fatalf("config mismatch: DisplayName is %q, but should have %q", is.DisplayName, should.DisplayName) } if should.StartType != is.StartType { t.Fatalf("config mismatch: StartType is %v, but should have %v", is.StartType, should.StartType) } if should.Description != is.Description { t.Fatalf("config mismatch: Description is %q, but should have %q", is.Description, should.Description) } if depString(should.Dependencies) != depString(is.Dependencies) { t.Fatalf("config mismatch: Dependencies is %v, but should have %v", is.Dependencies, should.Dependencies) } return is } func testRecoveryActions(t testing.T, s mgr.Service, should []mgr.RecoveryAction) { is, err := s.RecoveryActions() if err != nil { t.Fatalf("RecoveryActions failed: %s", err) } if len(should) != len(is) { t.Errorf("recovery action mismatch: contains %v actions, but should have %v", len(is), len(should)) } for i := range is { if should[i].Type != is[i].Type { t.Errorf("recovery action mismatch: Type is %v, but should have %v", is[i].Type, should[i].Type) } if should[i].Delay != is[i].Delay { t.Errorf("recovery action mismatch: Delay is %v, but should have %v", is[i].Delay, should[i].Delay) } } } func testResetPeriod(t testing.T, s mgr.Service, should uint32) { is, err := s.ResetPeriod() if err != nil { t.Fatalf("ResetPeriod failed: %s", err) } if should != is { t.Errorf("reset period mismatch: reset period is %v, but should have %v", is, should) } } func testSetRecoveryActions(t testing.T, s mgr.Service) { r := []mgr.RecoveryAction{ { Type: mgr.NoAction, Delay: 60000 * time.Millisecond, }, { Type: mgr.ServiceRestart, Delay: 4 * time.Minute, }, { Type: mgr.ServiceRestart, Delay: time.Minute, }, { Type: mgr.RunCommand, Delay: 4000 * time.Millisecond, }, } // 4 recovery actions with reset period err := s.SetRecoveryActions(r, uint32(10000)) if err != nil { t.Fatalf("SetRecoveryActions failed: %v", err) } testRecoveryActions(t, s, r) testResetPeriod(t, s, uint32(10000)) // Infinite reset period err = s.SetRecoveryActions(r, syscall.INFINITE) if err != nil { t.Fatalf("SetRecoveryActions failed: %v", err) } testRecoveryActions(t, s, r) testResetPeriod(t, s, syscall.INFINITE) // nil recovery actions err = s.SetRecoveryActions(nil, 0) if err.Error() != "recoveryActions cannot be nil" { t.Fatalf("SetRecoveryActions failed with unexpected error message of %q", err) } // Delete all recovery actions and reset period err = s.ResetRecoveryActions() if err != nil { t.Fatalf("ResetRecoveryActions failed: %v", err) } testRecoveryActions(t, s, nil) testResetPeriod(t, s, 0) } func testRebootMessage(t testing.T, s mgr.Service, should string) { err := s.SetRebootMessage(should) if err != nil { t.Fatalf("SetRebootMessage failed: %v", err) } is, err := s.RebootMessage() if err != nil { t.Fatalf("RebootMessage failed: %v", err) } if should != is { t.Errorf("reboot message mismatch: message is %q, but should have %q", is, should) } } func testRecoveryCommand(t testing.T, s mgr.Service, should string) { err := s.SetRecoveryCommand(should) if err != nil { t.Fatalf("SetRecoveryCommand failed: %v", err) } is, err := s.RecoveryCommand() if err != nil { t.Fatalf("RecoveryCommand failed: %v", err) } if should != is { t.Errorf("recovery command mismatch: command is %q, but should have %q", is, should) } } func testRecoveryActionsOnNonCrashFailures(t testing.T, s mgr.Service, should bool) { err := s.SetRecoveryActionsOnNonCrashFailures(should) if err != nil { t.Fatalf("SetRecoveryActionsOnNonCrashFailures failed: %v", err) } is, err := s.RecoveryActionsOnNonCrashFailures() if err != nil { t.Fatalf("RecoveryActionsOnNonCrashFailures failed: %v", err) } if should != is { t.Errorf("RecoveryActionsOnNonCrashFailures mismatch: flag is %v, but should have %v", is, should) } } func testMultipleRecoverySettings(t testing.T, s mgr.Service, rebootMsgShould, recoveryCmdShould string, actionsFlagShould bool) { err := s.SetRebootMessage(rebootMsgShould) if err != nil { t.Fatalf("SetRebootMessage failed: %v", err) } err = s.SetRecoveryActionsOnNonCrashFailures(actionsFlagShould) if err != nil { t.Fatalf("SetRecoveryActionsOnNonCrashFailures failed: %v", err) } err = s.SetRecoveryCommand(recoveryCmdShould) if err != nil { t.Fatalf("SetRecoveryCommand failed: %v", err) } rebootMsgIs, err := s.RebootMessage() if err != nil { t.Fatalf("RebootMessage failed: %v", err) } if rebootMsgShould != rebootMsgIs { t.Errorf("reboot message mismatch: message is %q, but should have %q", rebootMsgIs, rebootMsgShould) } recoveryCommandIs, err := s.RecoveryCommand() if err != nil { t.Fatalf("RecoveryCommand failed: %v", err) } if recoveryCmdShould != recoveryCommandIs { t.Errorf("recovery command mismatch: command is %q, but should have %q", recoveryCommandIs, recoveryCmdShould) } actionsFlagIs, err := s.RecoveryActionsOnNonCrashFailures() if err != nil { t.Fatalf("RecoveryActionsOnNonCrashFailures failed: %v", err) } if actionsFlagShould != actionsFlagIs { t.Errorf("RecoveryActionsOnNonCrashFailures mismatch: flag is %v, but should have %v", actionsFlagIs, actionsFlagShould) } } func testControl(t testing.T, s mgr.Service, c svc.Cmd, expectedErr error, expectedStatus svc.Status) { status, err := s.Control(c) if err != expectedErr { t.Fatalf("Unexpected return from s.Control: %v (expected %v)", err, expectedErr) } if expectedStatus != status { t.Fatalf("Unexpected status from s.Control: %+v (expected %+v)", status, expectedStatus) } } func remove(t testing.T, s mgr.Service) { err := s.Delete() if err != nil { t.Fatalf("Delete failed: %s", err) } } func TestMyService(t testing.T) { if os.Getenv("GO_BUILDER_NAME") == "" { // Don't install services on arbitrary users' machines. t.Skip("skipping test that modifies system services: GO_BUILDER_NAME not set") } if testing.Short() { t.Skip("skipping test in short mode that modifies system services") } const name = "mgrtestservice" m, err := mgr.Connect() if err != nil { t.Fatalf("SCM connection failed: %s", err) } defer m.Disconnect() c := mgr.Config{ StartType: mgr.StartDisabled, DisplayName: "x-sys mgr test service", Description: "x-sys mgr test service is just a test", Dependencies: []string{"LanmanServer", "W32Time"}, } exename := os.Args[0] exepath, err := filepath.Abs(exename) if err != nil { t.Fatalf("filepath.Abs(%s) failed: %s", exename, err) } install(t, m, name, exepath, c) s, err := m.OpenService(name) if err != nil { t.Fatalf("service %s is not installed", name) } defer s.Close() defer s.Delete() c.BinaryPathName = exepath c = testConfig(t, s, c) c.StartType = mgr.StartManual err = s.UpdateConfig(c) if err != nil { t.Fatalf("UpdateConfig failed: %v", err) } testConfig(t, s, c) c.StartType = mgr.StartAutomatic c.DelayedAutoStart = true err = s.UpdateConfig(c) if err != nil { t.Fatalf("UpdateConfig failed: %v", err) } testConfig(t, s, c) svcnames, err := m.ListServices() if err != nil { t.Fatalf("ListServices failed: %v", err) } var serviceIsInstalled bool for _, sn := range svcnames { if sn == name { serviceIsInstalled = true break } } if !serviceIsInstalled { t.Errorf("ListServices failed to find %q service", name) } testSetRecoveryActions(t, s) testRebootMessage(t, s, fmt.Sprintf("%s failed", name)) testRebootMessage(t, s, "") // delete reboot message testRecoveryCommand(t, s, fmt.Sprintf("sc query %s", name)) testRecoveryCommand(t, s, "") // delete recovery command testRecoveryActionsOnNonCrashFailures(t, s, true) testRecoveryActionsOnNonCrashFailures(t, s, false) testMultipleRecoverySettings(t, s, fmt.Sprintf("%s failed", name), fmt.Sprintf("sc query %s", name), true) expectedStatus := svc.Status{ State: svc.Stopped, } testControl(t, s, svc.Stop, windows.ERROR_SERVICE_NOT_ACTIVE, expectedStatus) remove(t, s) } func TestListDependentServices(t testing.T) { m, err := mgr.Connect() if err != nil { if errno, ok := err.(syscall.Errno); ok && errno == syscall.ERROR_ACCESS_DENIED { t.Skip("Skipping test: we don't have rights to manage services.") } t.Fatalf("SCM connection failed: %s", err) } defer m.Disconnect() baseServiceName := "testservice1" dependentServiceName := "testservice2" install(t, m, baseServiceName, "", mgr.Config{}) baseService, err := m.OpenService(baseServiceName) if err != nil { t.Fatalf("OpenService failed: %v", err) } defer remove(t, baseService) install(t, m, dependentServiceName, "", mgr.Config{Dependencies: []string{baseServiceName}}) dependentService, err := m.OpenService(dependentServiceName) if err != nil { t.Fatalf("OpenService failed: %v", err) } defer remove(t, dependentService) // test that both the base service and dependent service list the correct dependencies dependentServices, err := baseService.ListDependentServices(svc.AnyActivity) if err != nil { t.Fatalf("baseService.ListDependentServices failed: %v", err) } if len(dependentServices) != 1 \|\| dependentServices[0] != dependentServiceName { t.Errorf("Found %v, instead of expected contents %s", dependentServices, dependentServiceName) } dependentServices, err = dependentService.ListDependentServices(svc.AnyActivity) if err != nil { t.Fatalf("dependentService.ListDependentServices failed: %v", err) } if len(dependentServices) != 0 { t.Errorf("Found %v, where no service should be listed", dependentService) } }	11.37 KB	2025-05-25 12:27
📄 recovery.go // Copyright 2018 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build windows package mgr import ( "errors" "syscall" "time" "unsafe" "golang.org/x/sys/windows" ) const ( // Possible recovery actions that the service control manager can perform. NoAction = windows.SC_ACTION_NONE // no action ComputerReboot = windows.SC_ACTION_REBOOT // reboot the computer ServiceRestart = windows.SC_ACTION_RESTART // restart the service RunCommand = windows.SC_ACTION_RUN_COMMAND // run a command ) // RecoveryAction represents an action that the service control manager can perform when service fails. // A service is considered failed when it terminates without reporting a status of SERVICE_STOPPED to the service controller. type RecoveryAction struct { Type int // one of NoAction, ComputerReboot, ServiceRestart or RunCommand Delay time.Duration // the time to wait before performing the specified action } // SetRecoveryActions sets actions that service controller performs when service fails and // the time after which to reset the service failure count to zero if there are no failures, in seconds. // Specify INFINITE to indicate that service failure count should never be reset. func (s Service) SetRecoveryActions(recoveryActions []RecoveryAction, resetPeriod uint32) error { if recoveryActions == nil { return errors.New("recoveryActions cannot be nil") } actions := []windows.SC_ACTION{} for _, a := range recoveryActions { action := windows.SC_ACTION{ Type: uint32(a.Type), Delay: uint32(a.Delay.Nanoseconds() / 1000000), } actions = append(actions, action) } rActions := windows.SERVICE_FAILURE_ACTIONS{ ActionsCount: uint32(len(actions)), Actions: &actions[0], ResetPeriod: resetPeriod, } return windows.ChangeServiceConfig2(s.Handle, windows.SERVICE_CONFIG_FAILURE_ACTIONS, (byte)(unsafe.Pointer(&rActions))) } // RecoveryActions returns actions that service controller performs when service fails. // The service control manager counts the number of times service s has failed since the system booted. // The count is reset to 0 if the service has not failed for ResetPeriod seconds. // When the service fails for the Nth time, the service controller performs the action specified in element [N-1] of returned slice. // If N is greater than slice length, the service controller repeats the last action in the slice. func (s Service) RecoveryActions() ([]RecoveryAction, error) { b, err := s.queryServiceConfig2(windows.SERVICE_CONFIG_FAILURE_ACTIONS) if err != nil { return nil, err } p := (windows.SERVICE_FAILURE_ACTIONS)(unsafe.Pointer(&b[0])) if p.Actions == nil { return nil, err } actions := unsafe.Slice(p.Actions, int(p.ActionsCount)) var recoveryActions []RecoveryAction for _, action := range actions { recoveryActions = append(recoveryActions, RecoveryAction{Type: int(action.Type), Delay: time.Duration(action.Delay) * time.Millisecond}) } return recoveryActions, nil } // ResetRecoveryActions deletes both reset period and array of failure actions. func (s Service) ResetRecoveryActions() error { actions := make([]windows.SC_ACTION, 1) rActions := windows.SERVICE_FAILURE_ACTIONS{ Actions: &actions[0], } return windows.ChangeServiceConfig2(s.Handle, windows.SERVICE_CONFIG_FAILURE_ACTIONS, (byte)(unsafe.Pointer(&rActions))) } // ResetPeriod is the time after which to reset the service failure // count to zero if there are no failures, in seconds. func (s Service) ResetPeriod() (uint32, error) { b, err := s.queryServiceConfig2(windows.SERVICE_CONFIG_FAILURE_ACTIONS) if err != nil { return 0, err } p := (windows.SERVICE_FAILURE_ACTIONS)(unsafe.Pointer(&b[0])) return p.ResetPeriod, nil } // SetRebootMessage sets service s reboot message. // If msg is "", the reboot message is deleted and no message is broadcast. func (s Service) SetRebootMessage(msg string) error { rActions := windows.SERVICE_FAILURE_ACTIONS{ RebootMsg: syscall.StringToUTF16Ptr(msg), } return windows.ChangeServiceConfig2(s.Handle, windows.SERVICE_CONFIG_FAILURE_ACTIONS, (byte)(unsafe.Pointer(&rActions))) } // RebootMessage is broadcast to server users before rebooting in response to the ComputerReboot service controller action. func (s Service) RebootMessage() (string, error) { b, err := s.queryServiceConfig2(windows.SERVICE_CONFIG_FAILURE_ACTIONS) if err != nil { return "", err } p := (windows.SERVICE_FAILURE_ACTIONS)(unsafe.Pointer(&b[0])) return windows.UTF16PtrToString(p.RebootMsg), nil } // SetRecoveryCommand sets the command line of the process to execute in response to the RunCommand service controller action. // If cmd is "", the command is deleted and no program is run when the service fails. func (s Service) SetRecoveryCommand(cmd string) error { rActions := windows.SERVICE_FAILURE_ACTIONS{ Command: syscall.StringToUTF16Ptr(cmd), } return windows.ChangeServiceConfig2(s.Handle, windows.SERVICE_CONFIG_FAILURE_ACTIONS, (byte)(unsafe.Pointer(&rActions))) } // RecoveryCommand is the command line of the process to execute in response to the RunCommand service controller action. This process runs under the same account as the service. func (s Service) RecoveryCommand() (string, error) { b, err := s.queryServiceConfig2(windows.SERVICE_CONFIG_FAILURE_ACTIONS) if err != nil { return "", err } p := (windows.SERVICE_FAILURE_ACTIONS)(unsafe.Pointer(&b[0])) return windows.UTF16PtrToString(p.Command), nil } // SetRecoveryActionsOnNonCrashFailures sets the failure actions flag. If the // flag is set to false, recovery actions will only be performed if the service // terminates without reporting a status of SERVICE_STOPPED. If the flag is set // to true, recovery actions are also performed if the service stops with a // nonzero exit code. func (s Service) SetRecoveryActionsOnNonCrashFailures(flag bool) error { var setting windows.SERVICE_FAILURE_ACTIONS_FLAG if flag { setting.FailureActionsOnNonCrashFailures = 1 } return windows.ChangeServiceConfig2(s.Handle, windows.SERVICE_CONFIG_FAILURE_ACTIONS_FLAG, (byte)(unsafe.Pointer(&setting))) } // RecoveryActionsOnNonCrashFailures returns the current value of the failure // actions flag. If the flag is set to false, recovery actions will only be // performed if the service terminates without reporting a status of // SERVICE_STOPPED. If the flag is set to true, recovery actions are also // performed if the service stops with a nonzero exit code. func (s Service) RecoveryActionsOnNonCrashFailures() (bool, error) { b, err := s.queryServiceConfig2(windows.SERVICE_CONFIG_FAILURE_ACTIONS_FLAG) if err != nil { return false, err } p := (windows.SERVICE_FAILURE_ACTIONS_FLAG)(unsafe.Pointer(&b[0])) return p.FailureActionsOnNonCrashFailures != 0, nil }	6.76 KB	2025-05-25 12:27
📄 service.go // Copyright 2012 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build windows package mgr import ( "syscall" "unsafe" "golang.org/x/sys/windows" "golang.org/x/sys/windows/svc" ) // Service is used to access Windows service. type Service struct { Name string Handle windows.Handle } // Delete marks service s for deletion from the service control manager database. func (s Service) Delete() error { return windows.DeleteService(s.Handle) } // Close relinquish access to the service s. func (s Service) Close() error { return windows.CloseServiceHandle(s.Handle) } // Start starts service s. // args will be passed to svc.Handler.Execute. func (s Service) Start(args ...string) error { var p uint16 if len(args) > 0 { vs := make([]uint16, len(args)) for i := range vs { vs[i] = syscall.StringToUTF16Ptr(args[i]) } p = &vs[0] } return windows.StartService(s.Handle, uint32(len(args)), p) } // Control sends state change request c to the service s. It returns the most // recent status the service reported to the service control manager, and an // error if the state change request was not accepted. // Note that the returned service status is only set if the status change // request succeeded, or if it failed with error ERROR_INVALID_SERVICE_CONTROL, // ERROR_SERVICE_CANNOT_ACCEPT_CTRL, or ERROR_SERVICE_NOT_ACTIVE. func (s Service) Control(c svc.Cmd) (svc.Status, error) { var t windows.SERVICE_STATUS err := windows.ControlService(s.Handle, uint32(c), &t) if err != nil && err != windows.ERROR_INVALID_SERVICE_CONTROL && err != windows.ERROR_SERVICE_CANNOT_ACCEPT_CTRL && err != windows.ERROR_SERVICE_NOT_ACTIVE { return svc.Status{}, err } return svc.Status{ State: svc.State(t.CurrentState), Accepts: svc.Accepted(t.ControlsAccepted), }, err } // Query returns current status of service s. func (s Service) Query() (svc.Status, error) { var t windows.SERVICE_STATUS_PROCESS var needed uint32 err := windows.QueryServiceStatusEx(s.Handle, windows.SC_STATUS_PROCESS_INFO, (byte)(unsafe.Pointer(&t)), uint32(unsafe.Sizeof(t)), &needed) if err != nil { return svc.Status{}, err } return svc.Status{ State: svc.State(t.CurrentState), Accepts: svc.Accepted(t.ControlsAccepted), ProcessId: t.ProcessId, Win32ExitCode: t.Win32ExitCode, ServiceSpecificExitCode: t.ServiceSpecificExitCode, }, nil } // ListDependentServices returns the names of the services dependent on service s, which match the given status. func (s Service) ListDependentServices(status svc.ActivityStatus) ([]string, error) { var bytesNeeded, returnedServiceCount uint32 var services []windows.ENUM_SERVICE_STATUS for { var servicesPtr windows.ENUM_SERVICE_STATUS if len(services) > 0 { servicesPtr = &services[0] } allocatedBytes := uint32(len(services)) uint32(unsafe.Sizeof(windows.ENUM_SERVICE_STATUS{})) err := windows.EnumDependentServices(s.Handle, uint32(status), servicesPtr, allocatedBytes, &bytesNeeded, &returnedServiceCount) if err == nil { break } if err != syscall.ERROR_MORE_DATA { return nil, err } if bytesNeeded <= allocatedBytes { return nil, err } // ERROR_MORE_DATA indicates the provided buffer was too small, run the call again after resizing the buffer requiredSliceLen := bytesNeeded / uint32(unsafe.Sizeof(windows.ENUM_SERVICE_STATUS{})) if bytesNeeded%uint32(unsafe.Sizeof(windows.ENUM_SERVICE_STATUS{})) != 0 { requiredSliceLen += 1 } services = make([]windows.ENUM_SERVICE_STATUS, requiredSliceLen) } if returnedServiceCount == 0 { return nil, nil } // The slice mutated by EnumDependentServices may have a length greater than returnedServiceCount, any elements // past that should be ignored. var dependents []string for i := 0; i < int(returnedServiceCount); i++ { dependents = append(dependents, windows.UTF16PtrToString(services[i].ServiceName)) } return dependents, nil }	3.99 KB	2025-05-25 12:27

Terminal