def uninstall_driver(self):
hService = None
pServiceConfig = None
# dwBytesNeeded = 0
# cbBufSize = 0
try:
self.__stop_driver()
hService = win32service.OpenService(
self.hSCManager, 'WINIO', win32service.SERVICE_ALL_ACCESS)
# If QueryServiceConfig() can not return a correct config, it will
# throw exception!
pServiceConfig = win32service.QueryServiceConfig(hService)
# If service is set to load automatically, don't delete it!
# dwStartType
if (pServiceConfig[1] == win32service.SERVICE_DEMAND_START):
win32service.DeleteService(hService)
except pywintypes.error as e:
if e.winerror == EC_SERVICE_NOT_INSTALLED:
return
raise
def ReloadData(self):
service = self.GetSelService()
self.listCtrl.SetRedraw(0)
self.listCtrl.ResetContent()
svcs = win32service.EnumServicesStatus(self.scm)
i = 0
self.data = []
for svc in svcs:
try:
status = ('Unknown', 'Stopped', 'Starting', 'Stopping', 'Running',
'Continuing', 'Pausing', 'Paused')[svc[2][1]]
except:
status = 'Unknown'
s = win32service.OpenService(self.scm, svc[0], win32service.SERVICE_ALL_ACCESS)
cfg = win32service.QueryServiceConfig(s)
try:
startup = ('Boot', 'System', 'Automatic', 'Manual', 'Disabled')[cfg[1]]
except:
startup = 'Unknown'
win32service.CloseServiceHandle(s)
# svc[2][2] control buttons
pos = self.listCtrl.AddString(str(svc[1]) + '\t' + status + '\t' + startup)
self.listCtrl.SetItemData(pos, i)
self.data.append(tuple(svc[2]) + (svc[1], svc[0], ))
i = i + 1
if service and service[1] == svc[0]:
self.listCtrl.SetCurSel(pos)
self.OnListEvent(self.IDC_LIST, win32con.LBN_SELCHANGE)
self.listCtrl.SetRedraw(1)
def get_services(self, services_loaded):
scm = win32service.OpenSCManager(
None, None, win32service.SC_MANAGER_ENUMERATE_SERVICE)
svcs = win32service.EnumServicesStatus(scm)
for svc in svcs:
try:
sh_query_config = win32service.OpenService(
scm, svc[0], win32service.SERVICE_QUERY_CONFIG)
service_info = win32service.QueryServiceConfig(sh_query_config)
short_name = svc[0]
full_path = service_info[3]
sv = self.check_if_service_already_loaded(
short_name, full_path, services_loaded)
if sv:
sv.permissions = self.get_service_permissions(sv)
if not sv:
sk = Service()
sk.name = short_name
sk.display_name = svc[1]
sk.full_path = full_path
sk.paths = get_path_info(full_path)
sk.permissions = self.get_service_permissions(sv)
services_loaded.append(sk)
except:
pass
return services_loaded
def enable(self):
if win32service.QueryServiceConfig(
self._service_handle)[1] == win32service.SERVICE_DISABLED:
win32service.ChangeServiceConfig(self._service_handle,
win32service.SERVICE_NO_CHANGE,
win32service.SERVICE_DEMAND_START,
win32service.SERVICE_NO_CHANGE,
None, None, 0, None, None, None,
None)
def __get__(self, service, serviceType):
info = win32service.QueryServiceConfig(service.handle)
serviceType, startType, errorControl, binaryPathName, loadOrderGroup, \
tagId, dependencies, name, displayName = info
service.binaryPathName = str(binaryPathName)
service.disabled = (startType == win32service.SERVICE_DISABLED)
service.automatic = (startType == win32service.SERVICE_AUTO_START)
service.manual = (startType == win32service.SERVICE_DEMAND_START)
return getattr(service, self.attrName)
def get_service_info(self, n):
if not self.service_info:
try:
self.service_info = win32service.QueryServiceConfig(self.get_sh_query_config())
except:
pass
if self.service_info:
return self.service_info[n]
else:
return "[unknown]"
def QueryService(svc_name):
"""Query service and get its config."""
hscm = win32service.OpenSCManager(None, None,
win32service.SC_MANAGER_ALL_ACCESS)
result = None
try:
hs = win32serviceutil.SmartOpenService(hscm, svc_name,
win32service.SERVICE_ALL_ACCESS)
result = win32service.QueryServiceConfig(hs)
win32service.CloseServiceHandle(hs)
finally:
win32service.CloseServiceHandle(hscm)
return result
def __CreateFromExistingService(serviceConfigManagerHandle, serviceName):
serviceHandle = None
returnConfigs = {}
try:
serviceHandle = win32service.OpenService(serviceConfigManagerHandle,
serviceName.StringValue(),
win32service.SERVICE_QUERY_CONFIG)
savedConfigs = win32service.QueryServiceConfig(serviceHandle)
returnConfigs = {'ServiceName': serviceName}
for key, value in ServiceConfigurations.indexesOfServiceConfig.iteritems():
returnConfigs[key] = ConfigurationTypeFactory.CreateConfigurationType(key, savedConfigs[value], True)
finally:
if serviceHandle:
win32service.CloseServiceHandle(serviceHandle)
return returnConfigs
def enable(self):
hSCM = safe_open_scmanager()
try:
hSvc = safe_open_service(hSCM, self.resource.service_name)
if win32service.QueryServiceConfig(
hSvc)[1] == win32service.SERVICE_DISABLED:
win32service.ChangeServiceConfig(
hSvc, win32service.SERVICE_NO_CHANGE,
win32service.SERVICE_DEMAND_START,
win32service.SERVICE_NO_CHANGE, None, None, 0, None, None,
None, None)
win32service.CloseServiceHandle(hSvc)
except win32api.error, details:
raise Fail("Error enabling service {0}: {1}".format(
self.resource.service_name, details.winerror))
def OnInitDialog(self):
cfg = win32service.QueryServiceConfig(self.service)
self.GetDlgItem(self.IDC_BOOT + cfg[1]).SetCheck(1)
status = win32service.QueryServiceStatus(self.service)
if ((status[0] & win32service.SERVICE_KERNEL_DRIVER) or
(status[0] & win32service.SERVICE_FILE_SYSTEM_DRIVER)):
# driver
self.GetDlgItem(self.IDC_LABEL).SetWindowText('Device:')
else:
# service
self.GetDlgItem(self.IDC_LABEL).SetWindowText('Service:')
self.GetDlgItem(self.IDC_BOOT).EnableWindow(0)
self.GetDlgItem(self.IDC_SYSTEM).EnableWindow(0)
self.GetDlgItem(self.IDC_DEVICE).SetWindowText(str(self.name))
return dialog.Dialog.OnInitDialog(self)
def query_service(self):
"""
Query additional information about the service and store them into the
object.
"""
hService = winsvc.OpenService(self.scm_handle, self.ServiceName,
winsvc.SERVICE_QUERY_CONFIG)
lpServiceConfig = winsvc.QueryServiceConfig(hService)
winsvc.CloseServiceHandle(hService)
self.ServiceType = lpServiceConfig[0]
self.StartType = lpServiceConfig[1]
self.ErrorControl = lpServiceConfig[2]
self.BinaryPathName = lpServiceConfig[3]
self.LoadOrderGroup = lpServiceConfig[4]
self.TagId = lpServiceConfig[5]
self.Dependencies = lpServiceConfig[6]
self.ServiceStartName = lpServiceConfig[7]
self.DisplayName = lpServiceConfig[8]
def ConfigDict(self, service_name):
config_dict = {}
handle = self.makehandleService(service_name)
try:
config_list = win32service.QueryServiceConfig(handle)
#debug(config_list = config_list)
except:
# debug(ERROR = traceback.format_exc())
config_list = ()
if config_list:
config_dict.update({
'name': service_name,
'start': self.service_state.get(config_list[1]),
'dependencies': config_list[6],
'user': config_list[7],
'display_name': config_list[8],
})
#debug(config_dict = config_dict)
return config_dict
def svcStart(self, svc_name, svc_arg=None, machine=None):
accessSCM = win32con.GENERIC_READ
hscm = win32service.OpenSCManager(None, None, accessSCM)
try:
shandle = win32service.OpenService(hscm, svc_name, accessSCM)
try:
(service_type, start_type, error_control, path,
load_order_group, tag_id, dependencies, start_name,
display_name) = win32service.QueryServiceConfig(shandle)
for service_name in dependencies:
if (self.svcStatus(service_name, machine) == STOPPED):
self.logger.info(
"Starting {} service because {} depends on it.".
format(service_name, svc_name))
self.svcStart(service_name)
finally:
win32service.CloseServiceHandle(shandle)
finally:
win32service.CloseServiceHandle(hscm)
if not svc_arg is None:
if isinstance(svc_arg, str):
# win32service expects a list of string arguments
svc_arg = [svc_arg]
win32serviceutil.StartService(svc_name, svc_arg, machine)
status = self.svcStatus(svc_name, machine)
i = 0
while status == STARTING:
time.sleep(1)
status = self.svcStatus(svc_name, machine)
i = i + 1
if i > 60:
self.logger.info("Timeout starting %s service" % svc_name)
raise TimeoutError
return status
def analyze_all_services(self):
try:
df = pd.DataFrame(columns=[
"Short Name", "Long Name", "Service Type", "Start Type",
"Dependencies", "Full Command", "Bin Path", "ACLS",
"Vulnerable Permissions", "Can Edit Binpath",
"Is Unquoted Path"
])
total_services = 0 # Total Number of services
vuln_perms = 0 # Total number of services that have suspect/vulnerable permissions (ACLS)
vuln_conf = 0 # Total number of services where we can change the binpath as a standard user.
vuln_unquote = 0 # Total number of services with unquoted service paths
vuln_services = [
] # List of all services tht can potentially be exploited
service_config_manager = win32service.OpenSCManager(
"",
None,
win32service.SC_MANAGER_CONNECT
| win32service.SC_MANAGER_ENUMERATE_SERVICE
| win32service.SC_MANAGER_QUERY_LOCK_STATUS
| win32service.SERVICE_QUERY_CONFIG,
)
service_manager = win32service.OpenSCManager(
None, None, win32service.SC_MANAGER_ENUMERATE_SERVICE)
# Hacky way to get the total number of services
for service in win32service.EnumServicesStatus(
service_manager,
win32service.SERVICE_WIN32,
win32service.SERVICE_STATE_ALL,
):
total_services += 1
pbar = tqdm(total=total_services)
pbar.set_description("Analyzing Services")
# For each service, enumerate its values and check ACL's / binpath edits.
for service in win32service.EnumServicesStatus(
service_manager,
win32service.SERVICE_WIN32,
win32service.SERVICE_STATE_ALL,
):
acls = "" # Holds all ACL's obtained from filepaths.py
conf_check = False # Can we edit the current services configuration?
unquote_check = False # Check for unquoted service paths
access = win32service.OpenService(
service_config_manager,
service[0],
win32service.SERVICE_QUERY_CONFIG,
)
config = win32service.QueryServiceConfig(access)
service_short_name = str(service[0]).replace('"', "").strip()
service_long_name = str(service[1]).replace('"', "").strip()
service_type = self.__access_from_int(config[0])
service_start_type = self.__windows_objects.START_TYPE[
config[2]]
service_dependencies = str(config[6]).replace('"', "").strip()
raw_bin_path = str(config[3])
cleaned_bin_path = str(config[3]).replace('"', "").strip()
# find and cleanup the bin path due to CLI argument being present.
service_bin_path = re.findall(self.__windows_file_path,
cleaned_bin_path)[0]
service_bin_path = os.path.join(
service_bin_path[0] + ":\\",
service_bin_path[1] + service_bin_path[2])
# Analyze ACL's for the Bin Path:
#acl_list = fp.get_acl_list_return(service_bin_path)
acl_dict = self.__perms.get_file_path_acl(service_bin_path)
acl_list = acl_dict["acls"]
for i, acl in enumerate(acl_list):
if i == (len(acl_list) - 1):
acls += acl
else:
acls += f"{acl}\n"
# Check for bad ACL permissions:
suspect_service = self.__analysis.analyze_acls_from_list(
acl_list)
if suspect_service:
vuln_perms += 1
if service_short_name not in vuln_services:
vuln_services.append(service_short_name)
# Check if we can change the config:
try:
test = win32service.OpenService(
service_config_manager,
service[0],
win32service.SERVICE_CHANGE_CONFIG,
)
conf_check = True
vuln_conf += 1
if service_short_name not in vuln_services:
vuln_services.append(service_short_name)
except:
pass
# Check for unquoted service paths:
if ("program files" in raw_bin_path.lower()
and '"' not in raw_bin_path.lower()):
unquote_check = True
vuln_unquote += 1
if service_short_name not in vuln_services:
vuln_services.append(service_short_name)
# Write the final data to a file.
data = {
"Short Name": service_short_name,
"Long Name": service_long_name,
"Service Type": f"{config[0]} {service_type}",
"Start Type": service_start_type,
"Dependencies": service_dependencies,
"Full Command": cleaned_bin_path,
"Bin Path": service_bin_path,
"ACLS": acls,
"Vulnerable Permissions": suspect_service,
"Can Edit Binpath": conf_check,
"Is Unquoted Path": unquote_check
}
df = df.append(data, ignore_index=True)
pbar.update(1)
return {
"name": "Service Analysis",
"description":
"Analyze all services for weak ACLs, ability to change bin-path, and unquoted paths",
"dataframe": df,
"total_services": total_services,
"vuln_perms": vuln_perms,
"vuln_conf": vuln_conf,
"vuln_unquote": vuln_unquote,
"vuln_services": vuln_services
}
except Exception as e:
self.__print_exception()
exit(1)
References:
Prerequisites: []
Development Status: 3 - Alpha, 5 - Production/Stable
Environment: Console
Intended Audience: System Administrators, Developers, End Users/Desktop
License: Freeware, Freely Distributable
Natural Language: English, Chinese (Simplified)
Operating System: POSIX :: Linux, Microsoft :: Windows
Programming Language: Python :: 2.6
Programming Language: Python :: 2.7
Topic: Utilities
"""
import sys
import pywintypes
import win32service
try:
scm = win32service.OpenSCManager(None, None, win32service.SC_MANAGER_ALL_ACCESS)
except pywintypes.error as e:
for msg in (x.decode('gbk') if isinstance(x, str) else x for x in e):
print(msg),
sys.exit(1)
service_handle = win32service.OpenService(scm, 'XLServicePlatform', win32service.SC_MANAGER_ALL_ACCESS)
# https://docs.microsoft.com/en-us/windows/win32/api/winsvc/ns-winsvc-service_status?redirectedfrom=MSDN
dwCurrentState = win32service.QueryServiceStatus(service_handle)[1]
currentServiceConfig = win32service.QueryServiceConfig(service_handle)
# http://timgolden.me.uk/pywin32-docs/win32service__ChangeServiceConfig_meth.html
def folders_for_midax_services():
resume = 0
accessSCM = win32con.GENERIC_READ
accessSrv = win32service.SC_MANAGER_ALL_ACCESS
#Open Service Control Manager
hscm = win32service.OpenSCManager(None, None, accessSCM)
try:
#Enumerate Service Control Manager DB
typeFilter = win32service.SERVICE_WIN32
stateFilter = win32service.SERVICE_STATE_ALL
disabled = win32service.SERVICE_DISABLED
statuses = win32service.EnumServicesStatus(hscm, typeFilter, stateFilter)
for (short_name, desc, status) in statuses:
if desc.lower().startswith('midax'):
shandle = win32service.OpenService(hscm, short_name, accessSCM)
try:
(service_type, start_type, error_control, path, load_order_group, tag_id, dependencies, start_name, display_name) = win32service.QueryServiceConfig(shandle)
if '/SM' in path:
path = path.split('/SM', 1)[0]
path = path.strip('"')
if start_type == disabled:
continue
path = os.path.dirname(os.path.normcase(os.path.normpath(path)))
if os.path.isdir(path):
yield path, short_name
finally:
win32service.CloseServiceHandle(shandle)
finally:
win32service.CloseServiceHandle(hscm)
def info(name):
'''
Get information about a service on the system
Args:
name (str): The name of the service. This is not the display name. Use
``get_service_name`` to find the service name.
Returns:
dict: A dictionary containing information about the service.
CLI Example:
.. code-block:: bash
salt '*' service.info spooler
'''
try:
handle_scm = win32service.OpenSCManager(
None, None, win32service.SC_MANAGER_CONNECT)
except pywintypes.error as exc:
raise CommandExecutionError('Failed to connect to the SCM: {0}'.format(
exc[2]))
try:
handle_svc = win32service.OpenService(
handle_scm, name, win32service.SERVICE_ENUMERATE_DEPENDENTS
| win32service.SERVICE_INTERROGATE
| win32service.SERVICE_QUERY_CONFIG
| win32service.SERVICE_QUERY_STATUS)
except pywintypes.error as exc:
raise CommandExecutionError('Failed To Open {0}: {1}'.format(
name, exc[2]))
try:
config_info = win32service.QueryServiceConfig(handle_svc)
status_info = win32service.QueryServiceStatusEx(handle_svc)
try:
description = win32service.QueryServiceConfig2(
handle_svc, win32service.SERVICE_CONFIG_DESCRIPTION)
except pywintypes.error:
description = 'Failed to get description'
delayed_start = win32service.QueryServiceConfig2(
handle_svc, win32service.SERVICE_CONFIG_DELAYED_AUTO_START_INFO)
finally:
win32service.CloseServiceHandle(handle_scm)
win32service.CloseServiceHandle(handle_svc)
ret = dict()
try:
sid = win32security.LookupAccountName(
'', 'NT Service\\{0}'.format(name))[0]
ret['sid'] = win32security.ConvertSidToStringSid(sid)
except pywintypes.error:
ret['sid'] = 'Failed to get SID'
ret['BinaryPath'] = config_info[3]
ret['LoadOrderGroup'] = config_info[4]
ret['TagID'] = config_info[5]
ret['Dependencies'] = config_info[6]
ret['ServiceAccount'] = config_info[7]
ret['DisplayName'] = config_info[8]
ret['Description'] = description
ret['Status_ServiceCode'] = status_info['ServiceSpecificExitCode']
ret['Status_CheckPoint'] = status_info['CheckPoint']
ret['Status_WaitHint'] = status_info['WaitHint']
ret['StartTypeDelayed'] = delayed_start
flags = list()
for bit in SERVICE_TYPE:
if isinstance(bit, int):
if config_info[0] & bit:
flags.append(SERVICE_TYPE[bit])
ret['ServiceType'] = flags if flags else config_info[0]
flags = list()
for bit in SERVICE_CONTROLS:
if status_info['ControlsAccepted'] & bit:
flags.append(SERVICE_CONTROLS[bit])
ret['ControlsAccepted'] = flags if flags else status_info[
'ControlsAccepted']
try:
ret['Status_ExitCode'] = SERVICE_ERRORS[status_info['Win32ExitCode']]
except KeyError:
ret['Status_ExitCode'] = status_info['Win32ExitCode']
try:
ret['StartType'] = SERVICE_START_TYPE[config_info[1]]
except KeyError:
ret['StartType'] = config_info[1]
try:
ret['ErrorControl'] = SERVICE_ERROR_CONTROL[config_info[2]]
except KeyError:
ret['ErrorControl'] = config_info[2]
try:
ret['Status'] = SERVICE_STATE[status_info['CurrentState']]
except KeyError:
ret['Status'] = status_info['CurrentState']
return ret
def is_resolution_ok(self):
try:
height = None
width = None
scm = win32service.OpenSCManager('localhost', None, win32service.SC_MANAGER_CONNECT)
s = win32service.OpenService(scm, 'Alyvix Background Service', win32service.SERVICE_QUERY_CONFIG)
cfg = win32service.QueryServiceConfig(s)
config_file = os.path.dirname(str(cfg[3]).replace("\"","")) + os.sep + "AlyvixBackgroundService.exe.config"
lines = []
with open(str(config_file)) as f:
lines = f.readlines()
for line in lines:
if "height" in line:
height = line.replace("<add key=\"height\" value=\"","")
height = height.replace("\"/>", "")
height = height.replace(" ","")
height = height.replace("\t","")
height = int(height)
if "width" in line:
width = line.replace("<add key=\"width\" value=\"", "")
width = width.replace("\"/>", "")
width = width.replace(" ", "")
width = width.replace("\t", "")
width = int(width)
if height is not None and width is not None:
hwnd = win32gui.GetDesktopWindow()
wDC = win32gui.GetWindowDC(hwnd)
dcObj = win32ui.CreateDCFromHandle(wDC)
HORZRES = 8
VERTRES = 10
DESKTOPHORZRES = 118
DESKTOPVERTRES = 117
v_HORZRES = dcObj.GetDeviceCaps(HORZRES)
v_VERTRES = dcObj.GetDeviceCaps(VERTRES)
v_DESKTOPHORZRES = dcObj.GetDeviceCaps(DESKTOPHORZRES)
v_DESKTOPVERTRES = dcObj.GetDeviceCaps(DESKTOPVERTRES)
dcObj.DeleteDC()
scaling = round(float(v_DESKTOPVERTRES) / float(v_VERTRES), 2) # two decimal
#if scaling >= 1.0:
# return False
if width == 1366: #fix for the windows 7 bug with rdp and 1366x768 res
if v_DESKTOPHORZRES >= 1364 and v_DESKTOPHORZRES <= 1368\
and height == v_DESKTOPVERTRES:
return True
else:
return False
elif height != v_DESKTOPVERTRES or width != v_DESKTOPHORZRES:
return False
except:
pass
return True
def get_service_username(self, service_name):
LOG.debug('Getting service username: %s', service_name)
with self._get_service_handle(service_name) as hs:
cfg = win32service.QueryServiceConfig(hs)
return cfg[7]
def modify(
name,
bin_path=None,
exe_args=None,
display_name=None,
description=None,
service_type=None,
start_type=None,
start_delayed=None,
error_control=None,
load_order_group=None,
dependencies=None,
account_name=None,
account_password=None,
run_interactive=None,
):
# pylint: disable=anomalous-backslash-in-string
"""
Modify a service's parameters. Changes will not be made for parameters that
are not passed.
.. versionadded:: 2016.11.0
Args:
name (str):
The name of the service. Can be found using the
``service.get_service_name`` function
bin_path (str):
The path to the service executable. Backslashes must be escaped, eg:
``C:\\path\\to\\binary.exe``
exe_args (str):
Any arguments required by the service executable
display_name (str):
The name to display in the service manager
description (str):
The description to display for the service
service_type (str):
Specifies the service type. Default is ``own``. Valid options are as
follows:
- kernel: Driver service
- filesystem: File system driver service
- adapter: Adapter driver service (reserved)
- recognizer: Recognizer driver service (reserved)
- own (default): Service runs in its own process
- share: Service shares a process with one or more other services
start_type (str):
Specifies the service start type. Valid options are as follows:
- boot: Device driver that is loaded by the boot loader
- system: Device driver that is started during kernel initialization
- auto: Service that automatically starts
- manual: Service must be started manually
- disabled: Service cannot be started
start_delayed (bool):
Set the service to Auto(Delayed Start). Only valid if the start_type
is set to ``Auto``. If service_type is not passed, but the service
is already set to ``Auto``, then the flag will be set.
error_control (str):
The severity of the error, and action taken, if this service fails
to start. Valid options are as follows:
- normal: Error is logged and a message box is displayed
- severe: Error is logged and computer attempts a restart with the
last known good configuration
- critical: Error is logged, computer attempts to restart with the
last known good configuration, system halts on failure
- ignore: Error is logged and startup continues, no notification is
given to the user
load_order_group (str):
The name of the load order group to which this service belongs
dependencies (list):
A list of services or load ordering groups that must start before
this service
account_name (str):
The name of the account under which the service should run. For
``own`` type services this should be in the ``domain\\username``
format. The following are examples of valid built-in service
accounts:
- NT Authority\\LocalService
- NT Authority\\NetworkService
- NT Authority\\LocalSystem
- .\\LocalSystem
account_password (str):
The password for the account name specified in ``account_name``. For
the above built-in accounts, this can be None. Otherwise a password
must be specified.
run_interactive (bool):
If this setting is True, the service will be allowed to interact
with the user. Not recommended for services that run with elevated
privileges.
Returns:
dict: a dictionary of changes made
CLI Example:
.. code-block:: bash
salt '*' service.modify spooler start_type=disabled
"""
# pylint: enable=anomalous-backslash-in-string
# https://msdn.microsoft.com/en-us/library/windows/desktop/ms681987(v=vs.85).aspx
# https://msdn.microsoft.com/en-us/library/windows/desktop/ms681988(v-vs.85).aspx
handle_scm = win32service.OpenSCManager(None, None, win32service.SC_MANAGER_CONNECT)
try:
handle_svc = win32service.OpenService(
handle_scm,
name,
win32service.SERVICE_CHANGE_CONFIG | win32service.SERVICE_QUERY_CONFIG,
)
except pywintypes.error as exc:
raise CommandExecutionError("Failed To Open {}: {}".format(name, exc.strerror))
config_info = win32service.QueryServiceConfig(handle_svc)
changes = dict()
# Input Validation
if bin_path is not None:
# shlex.quote the path to the binary
bin_path = _cmd_quote(bin_path)
if exe_args is not None:
bin_path = "{} {}".format(bin_path, exe_args)
changes["BinaryPath"] = bin_path
if service_type is not None:
if service_type.lower() in SERVICE_TYPE:
service_type = SERVICE_TYPE[service_type.lower()]
if run_interactive:
service_type = service_type | win32service.SERVICE_INTERACTIVE_PROCESS
else:
raise CommandExecutionError("Invalid Service Type: {}".format(service_type))
else:
if run_interactive is True:
service_type = config_info[0] | win32service.SERVICE_INTERACTIVE_PROCESS
elif run_interactive is False:
service_type = config_info[0] ^ win32service.SERVICE_INTERACTIVE_PROCESS
else:
service_type = win32service.SERVICE_NO_CHANGE
if service_type is not win32service.SERVICE_NO_CHANGE:
flags = list()
for bit in SERVICE_TYPE:
if isinstance(bit, int) and service_type & bit:
flags.append(SERVICE_TYPE[bit])
changes["ServiceType"] = flags if flags else service_type
if start_type is not None:
if start_type.lower() in SERVICE_START_TYPE:
start_type = SERVICE_START_TYPE[start_type.lower()]
else:
raise CommandExecutionError("Invalid Start Type: {}".format(start_type))
changes["StartType"] = SERVICE_START_TYPE[start_type]
else:
start_type = win32service.SERVICE_NO_CHANGE
if error_control is not None:
if error_control.lower() in SERVICE_ERROR_CONTROL:
error_control = SERVICE_ERROR_CONTROL[error_control.lower()]
else:
raise CommandExecutionError(
"Invalid Error Control: {}".format(error_control)
)
changes["ErrorControl"] = SERVICE_ERROR_CONTROL[error_control]
else:
error_control = win32service.SERVICE_NO_CHANGE
if account_name is not None:
changes["ServiceAccount"] = account_name
if account_name in ["LocalSystem", "LocalService", "NetworkService"]:
account_password = ""
if account_password is not None:
changes["ServiceAccountPassword"] = "******"
if load_order_group is not None:
changes["LoadOrderGroup"] = load_order_group
if dependencies is not None:
changes["Dependencies"] = dependencies
if display_name is not None:
changes["DisplayName"] = display_name
win32service.ChangeServiceConfig(
handle_svc,
service_type,
start_type,
error_control,
bin_path,
load_order_group,
0,
dependencies,
account_name,
account_password,
display_name,
)
if description is not None:
win32service.ChangeServiceConfig2(
handle_svc, win32service.SERVICE_CONFIG_DESCRIPTION, description
)
changes["Description"] = description
if start_delayed is not None:
# You can only set delayed start for services that are set to auto start
# Start type 2 is Auto
# Start type -1 is no change
if (start_type == -1 and config_info[1] == 2) or start_type == 2:
win32service.ChangeServiceConfig2(
handle_svc,
win32service.SERVICE_CONFIG_DELAYED_AUTO_START_INFO,
start_delayed,
)
changes["StartTypeDelayed"] = start_delayed
else:
changes["Warning"] = 'start_delayed: Requires start_type "auto"'
win32service.CloseServiceHandle(handle_scm)
win32service.CloseServiceHandle(handle_svc)
return changes
self.ctx.out(io2[0].strip())
else:
self.ctx.err("UNKNOWN!")
if self._isWindows():
# Print the OMERO server Windows service details
hscm = win32service.OpenSCManager(
None, None, win32service.SC_MANAGER_ALL_ACCESS)
services = win32service.EnumServicesStatus(hscm)
omesvcs = tuple((sname, fname)
for sname, fname, status in services
if "OMERO" in fname)
for sname, fname in omesvcs:
item("Server", fname)
hsc = win32service.OpenService(
hscm, sname, win32service.SC_MANAGER_ALL_ACCESS)
logonuser = win32service.QueryServiceConfig(hsc)[7]
if win32service.QueryServiceStatus(hsc)[1] == \
win32service.SERVICE_RUNNING:
self.ctx.out("active (running as %s)" % logonuser)
else:
self.ctx.out("inactive")
win32service.CloseServiceHandle(hsc)
win32service.CloseServiceHandle(hscm)
# List SSL & TCP ports of deployed applications
self.ctx.out("")
p = self.ctx.popen(self._cmd("-e", "application list")) # popen
rv = p.wait()
io = p.communicate()
if rv != 0:
self.ctx.out("Cannot list deployed applications.")
