| 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 |
} |