Debian Codegraph @

windows/svc/mgr/mgr.go

raw
1 // Copyright 2012 The Go Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
4
5 //go:build windows
6
7 // Package mgr can be used to manage Windows service programs.
8 // It can be used to install and remove them. It can also start,
9 // stop and pause them. The package can query / change current
10 // service state and config parameters.
11 package mgr
12
13 import (
14 "syscall"
15 "time"
16 "unicode/utf16"
17 "unsafe"
18
19 "golang.org/x/sys/windows"
20 )
21
22 // Mgr is used to manage Windows service.
23 type Mgr struct {
24 Handle windows.Handle
25 }
26
27 // Connect establishes a connection to the service control manager.
28 func Connect() (*Mgr, error) {
29 return ConnectRemote("")
30 }
31
32 // ConnectRemote establishes a connection to the
33 // service control manager on computer named host.
34 func ConnectRemote(host string) (*Mgr, error) {
35 var s *uint16
36 if host != "" {
37 var err error
38 s, err = syscall.UTF16PtrFromString(host)
39 if err != nil {
40 return nil, err
41 }
42 }
43 h, err := windows.OpenSCManager(s, nil, windows.SC_MANAGER_ALL_ACCESS)
44 if err != nil {
45 return nil, err
46 }
47 return &Mgr{Handle: h}, nil
48 }
49
50 // Disconnect closes connection to the service control manager m.
51 func (m *Mgr) Disconnect() error {
52 return windows.CloseServiceHandle(m.Handle)
53 }
54
55 type LockStatus struct {
56 IsLocked bool // Whether the SCM has been locked.
57 Age time.Duration // For how long the SCM has been locked.
58 Owner string // The name of the user who has locked the SCM.
59 }
60
61 // LockStatus returns whether the service control manager is locked by
62 // the system, for how long, and by whom. A locked SCM indicates that
63 // most service actions will block until the system unlocks the SCM.
64 func (m *Mgr) LockStatus() (*LockStatus, error) {
65 bytesNeeded := uint32(unsafe.Sizeof(windows.QUERY_SERVICE_LOCK_STATUS{}) + 1024)
66 for {
67 bytes := make([]byte, bytesNeeded)
68 lockStatus := (*windows.QUERY_SERVICE_LOCK_STATUS)(unsafe.Pointer(&bytes[0]))
69 err := windows.QueryServiceLockStatus(m.Handle, lockStatus, uint32(len(bytes)), &bytesNeeded)
70 if err == windows.ERROR_INSUFFICIENT_BUFFER && bytesNeeded >= uint32(unsafe.Sizeof(windows.QUERY_SERVICE_LOCK_STATUS{})) {
71 continue
72 }
73 if err != nil {
74 return nil, err
75 }
76 status := &LockStatus{
77 IsLocked: lockStatus.IsLocked != 0,
78 Age: time.Duration(lockStatus.LockDuration) * time.Second,
79 Owner: windows.UTF16PtrToString(lockStatus.LockOwner),
80 }
81 return status, nil
82 }
83 }
84
85 func toPtr(s string) (*uint16, error) {
86 if len(s) == 0 {
87 return nil, nil
88 }
89 return syscall.UTF16PtrFromString(s)
90 }
91
92 // toStringBlock terminates strings in ss with 0, and then
93 // concatenates them together. It also adds extra 0 at the end.
94 func toStringBlock(ss []string) *uint16 {
95 if len(ss) == 0 {
96 return nil
97 }
98 t := ""
99 for _, s := range ss {
100 if s != "" {
101 t += s + "\x00"
102 }
103 }
104 if t == "" {
105 return nil
106 }
107 t += "\x00"
108 return &utf16.Encode([]rune(t))[0]
109 }
110
111 // CreateService installs new service name on the system.
112 // The service will be executed by running exepath binary.
113 // Use config c to specify service parameters.
114 // Any args will be passed as command-line arguments when
115 // the service is started; these arguments are distinct from
116 // the arguments passed to Service.Start or via the "Start
117 // parameters" field in the service's Properties dialog box.
118 func (m *Mgr) CreateService(name, exepath string, c Config, args ...string) (*Service, error) {
119 if c.StartType == 0 {
120 c.StartType = StartManual
121 }
122 if c.ServiceType == 0 {
123 c.ServiceType = windows.SERVICE_WIN32_OWN_PROCESS
124 }
125 s := syscall.EscapeArg(exepath)
126 for _, v := range args {
127 s += " " + syscall.EscapeArg(v)
128 }
129 namePointer, err := toPtr(name)
130 if err != nil {
131 return nil, err
132 }
133 displayNamePointer, err := toPtr(c.DisplayName)
134 if err != nil {
135 return nil, err
136 }
137 sPointer, err := toPtr(s)
138 if err != nil {
139 return nil, err
140 }
141 loadOrderGroupPointer, err := toPtr(c.LoadOrderGroup)
142 if err != nil {
143 return nil, err
144 }
145 serviceStartNamePointer, err := toPtr(c.ServiceStartName)
146 if err != nil {
147 return nil, err
148 }
149 passwordPointer, err := toPtr(c.Password)
150 if err != nil {
151 return nil, err
152 }
153 h, err := windows.CreateService(m.Handle, namePointer, displayNamePointer,
154 windows.SERVICE_ALL_ACCESS, c.ServiceType,
155 c.StartType, c.ErrorControl, sPointer, loadOrderGroupPointer,
156 nil, toStringBlock(c.Dependencies), serviceStartNamePointer, passwordPointer)
157 if err != nil {
158 return nil, err
159 }
160 if c.SidType != windows.SERVICE_SID_TYPE_NONE {
161 err = updateSidType(h, c.SidType)
162 if err != nil {
163 windows.DeleteService(h)
164 windows.CloseServiceHandle(h)
165 return nil, err
166 }
167 }
168 if c.Description != "" {
169 err = updateDescription(h, c.Description)
170 if err != nil {
171 windows.DeleteService(h)
172 windows.CloseServiceHandle(h)
173 return nil, err
174 }
175 }
176 if c.DelayedAutoStart {
177 err = updateStartUp(h, c.DelayedAutoStart)
178 if err != nil {
179 windows.DeleteService(h)
180 windows.CloseServiceHandle(h)
181 return nil, err
182 }
183 }
184 return &Service{Name: name, Handle: h}, nil
185 }
186
187 // OpenService retrieves access to service name, so it can
188 // be interrogated and controlled.
189 func (m *Mgr) OpenService(name string) (*Service, error) {
190 namePointer, err := syscall.UTF16PtrFromString(name)
191 if err != nil {
192 return nil, err
193 }
194
195 h, err := windows.OpenService(m.Handle, namePointer, windows.SERVICE_ALL_ACCESS)
196 if err != nil {
197 return nil, err
198 }
199 return &Service{Name: name, Handle: h}, nil
200 }
201
202 // ListServices enumerates services in the specified
203 // service control manager database m.
204 // If the caller does not have the SERVICE_QUERY_STATUS
205 // access right to a service, the service is silently
206 // omitted from the list of services returned.
207 func (m *Mgr) ListServices() ([]string, error) {
208 var err error
209 var bytesNeeded, servicesReturned uint32
210 var buf []byte
211 for {
212 var p *byte
213 if len(buf) > 0 {
214 p = &buf[0]
215 }
216 err = windows.EnumServicesStatusEx(m.Handle, windows.SC_ENUM_PROCESS_INFO,
217 windows.SERVICE_WIN32, windows.SERVICE_STATE_ALL,
218 p, uint32(len(buf)), &bytesNeeded, &servicesReturned, nil, nil)
219 if err == nil {
220 break
221 }
222 if err != syscall.ERROR_MORE_DATA {
223 return nil, err
224 }
225 if bytesNeeded <= uint32(len(buf)) {
226 return nil, err
227 }
228 buf = make([]byte, bytesNeeded)
229 }
230 if servicesReturned == 0 {
231 return nil, nil
232 }
233 services := unsafe.Slice((*windows.ENUM_SERVICE_STATUS_PROCESS)(unsafe.Pointer(&buf[0])), int(servicesReturned))
234
235 var names []string
236 for _, s := range services {
237 name := windows.UTF16PtrToString(s.ServiceName)
238 names = append(names, name)
239 }
240 return names, nil
241 }