def create(self):
if not self.driver or not os.path.exists(self.driver):
if self.debug:
print "The driver does not exist at path: {0}".format(self.driver)
return
if self.debug:
print "Trying to create service", self.service_name, self.driver
try:
if not self.service:
self.service = win32service.CreateService(
self.manager,
self.service_name,
self.service_name,
win32service.SERVICE_ALL_ACCESS,
win32service.SERVICE_KERNEL_DRIVER,
win32service.SERVICE_DEMAND_START,
win32service.SERVICE_ERROR_IGNORE,
self.driver,
None, 0, None, None, None)
except win32service.error as e:
if self.debug:
print "Unable to create service: {0}".format(e)
self.service = win32service.OpenService(self.manager, self.service_name,
win32service.SERVICE_ALL_ACCESS)
try:
win32service.ControlService(self.service, win32service.SERVICE_CONTROL_STOP)
except win32service.error:
pass
def action_stop(self):
self._service_handle = self._service_handle if hasattr(self, "_service_handle") else \
win32service.OpenService(_schSCManager, self.resource.service_name, win32service.SERVICE_ALL_ACCESS)
if self.status():
win32service.ControlService(self._service_handle,
win32service.SERVICE_CONTROL_STOP)
self.wait_status(win32service.SERVICE_STOPPED)
def remove_service(self, also_close_as=True):
self.session.logging.debug("Removing service %s",
self.plugin_args.service_name)
# Make sure the handle is closed.
if also_close_as:
self.session.physical_address_space.close()
# Stop the service if it's running.
if not self.hSvc:
try:
self.hSvc = win32service.OpenService(
self.hScm, self.plugin_args.service_name,
win32service.SERVICE_ALL_ACCESS)
except win32service.error:
self.session.logging.debug("%s service does not exist.",
self.plugin_args.service_name)
if self.hSvc:
self.session.logging.debug("Stopping service: %s",
self.plugin_args.service_name)
try:
win32service.ControlService(self.hSvc,
win32service.SERVICE_CONTROL_STOP)
except win32service.error as e:
self.session.logging.debug("Error stopping service: %s", e)
self.session.logging.debug("Deleting service: %s",
self.plugin_args.service_name)
try:
win32service.DeleteService(self.hSvc)
except win32service.error as e:
self.session.logging.debug("Error deleting service: %s", e)
win32service.CloseServiceHandle(self.hSvc)
def stopasync(self, args, config):
"""
Returns true if the server was already stopped
"""
self.check_node(args)
if 0 != self.status(args, node_only=True):
self.ctx.err("Server not running")
return True
elif self._isWindows():
svc_name = "OMERO.%s" % args.node
output = self._query_service(svc_name)
if 0 <= output.find("DOESNOTEXIST"):
self.ctx.die(
203, "%s does not exist. Use 'start' first." % svc_name)
hscm = win32service.OpenSCManager(
None, None, win32service.SC_MANAGER_ALL_ACCESS)
try:
hs = win32service.OpenService(
hscm, svc_name, win32service.SC_MANAGER_ALL_ACCESS)
win32service.ControlService(hs,
win32service.SERVICE_CONTROL_STOP)
win32service.DeleteService(hs)
self.ctx.out("%s service deleted." % svc_name)
finally:
win32service.CloseServiceHandle(hs)
win32service.CloseServiceHandle(hscm)
else:
command = self._cmd("-e", "node shutdown %s" % self._node())
try:
self.ctx.call(command)
except NonZeroReturnCode, nzrc:
self.ctx.rv = nzrc.rv
self.ctx.out("Was the server already stopped?")
def stopService():
"""Stop the running service and wait for its process to die.
"""
scm = win32service.OpenSCManager(None, None,
win32service.SC_MANAGER_ALL_ACCESS)
try:
serv = win32service.OpenService(scm, NVDAService._svc_name_,
win32service.SERVICE_ALL_ACCESS)
try:
pid = win32service.QueryServiceStatusEx(serv)["ProcessId"]
# Stop the service.
win32service.ControlService(serv,
win32service.SERVICE_CONTROL_STOP)
# Wait for the process to exit.
proc = AutoHANDLE(
windll.kernel32.OpenProcess(SYNCHRONIZE, False, pid))
if not proc:
return
windll.kernel32.WaitForSingleObject(proc, INFINITE)
finally:
win32service.CloseServiceHandle(serv)
finally:
win32service.CloseServiceHandle(scm)
def stop(self):
"""停止服务"""
try:
status_info = win32service.ControlService(
self.handle, win32service.SERVICE_CONTROL_STOP)
except Exception, e:
self.log(e)
def stop(self):
"""Stop service"""
try:
status_info = win32service.ControlService(
self.handle, win32service.SERVICE_CONTROL_STOP)
except Exception as e:
logging.info(e)
if status_info[1] == win32service.SERVICE_STOPPED:
logging.info('Stop %s successfully.', self.name)
return 'Stop %s successfully.' % (self.name)
elif status_info[1] == win32service.SERVICE_STOP_PENDING:
start_time = datetime.datetime.now()
while True:
if (datetime.datetime.now() -
start_time).seconds > self.delay_time:
logging.info('Stop %s too much time.', self.name)
return 'Stop %s too much time.' % (self.name)
time.sleep(self.wait_time)
if win32service.QueryServiceStatus(
self.handle)[1] == win32service.SERVICE_STOPPED:
logging.info('Stop %s successfully.', self.name)
return 'Stop %s successfully.' % (self.name)
else:
logging.info('Stop %s fail.', self.name)
return 'Stop %s fail.' % (self.name)
def sc(serviceName):
# 获取“服务管理器”的句柄
scHandle = win32service.OpenSCManager(None, None,
win32service.SC_MANAGER_ALL_ACCESS)
# do something ...
print 'got SCM handle : %(scHandle)s' % locals()
# 获取某个服务的句柄
serviceHandle = win32service.OpenService(scHandle, serviceName,
win32service.SC_MANAGER_ALL_ACCESS)
# 利用句柄查询该服务的状态信息
status = win32service.QueryServiceStatus(serviceHandle)
PrintServiceStatus(status)
# 也可以直接通过服务的名称来查询状态
status = win32serviceutil.QueryServiceStatus(serviceName)
# 停止该服务
if isServiceRunning(serviceName):
status = win32service.ControlService(serviceHandle, win32service.SERVICE_CONTROL_STOP)
PrintServiceStatus(status)
# 启动该服务
if not isServiceRunning(serviceName):
win32serviceutil.StartService(serviceName)
PrintServiceStatus(win32serviceutil.QueryServiceStatus(serviceName))
# 释放所取得的所有句柄
win32service.CloseServiceHandle(serviceHandle)
win32service.CloseServiceHandle(scHandle)
def __StopServiceWithTimeout(hs, waitSecs=30):
try:
status = win32service.ControlService(hs,
win32service.SERVICE_CONTROL_STOP)
except pywintypes.error, exc:
if exc.winerror != winerror.ERROR_SERVICE_NOT_ACTIVE:
raise
def load_driver(self):
"""Load the driver if possible."""
# Check the driver is somewhere accessible.
if self.driver is None:
# Valid values
# http://superuser.com/questions/305901/possible-values-of-processor-architecture
machine = platform.machine()
if machine == "AMD64":
driver = "winpmem_x64.sys"
elif machine == "x86":
driver = "winpmem_x86.sys"
else:
raise plugin.PluginError("Unsupported architecture")
self.driver = rekall.get_resource("WinPmem/%s" % driver)
# Try the local directory
if self.driver is None:
self.driver = os.path.join(os.getcwd(), "WinPmem", driver)
self.session.logging.debug("Loading driver from %s", self.driver)
if not os.access(self.driver, os.R_OK):
raise plugin.PluginError("Driver file %s is not accessible." %
self.driver)
# Must have absolute path here.
self.hScm = win32service.OpenSCManager(
None, None, win32service.SC_MANAGER_CREATE_SERVICE)
try:
self.hSvc = win32service.CreateService(
self.hScm, self.name, self.name,
win32service.SERVICE_ALL_ACCESS,
win32service.SERVICE_KERNEL_DRIVER,
win32service.SERVICE_DEMAND_START,
win32service.SERVICE_ERROR_IGNORE, self.driver, None, 0, None,
None, None)
self.session.logging.debug("Created service %s", self.name)
# Remember to cleanup afterwards.
self.we_started_service = True
except win32service.error as e:
# Service is already there, try to open it instead.
self.hSvc = win32service.OpenService(
self.hScm, self.name, win32service.SERVICE_ALL_ACCESS)
# Make sure the service is stopped.
try:
win32service.ControlService(self.hSvc,
win32service.SERVICE_CONTROL_STOP)
except win32service.error:
pass
try:
win32service.StartService(self.hSvc, [])
except win32service.error, e:
self.session.logging.debug("%s: will try to continue", e)
def stop_and_delete_driver_service(h_svc):
"""Stops the winpmem service and delete it"""
try:
win32service.ControlService(h_svc, win32service.SERVICE_CONTROL_STOP)
except win32service.error:
pass
win32service.DeleteService(h_svc)
win32service.CloseServiceHandle(h_svc)
def OnContinueCmd(self, id, code): service = self.GetSelService() if not service: return s = win32service.OpenService(self.scm, service[1], win32service.SERVICE_ALL_ACCESS) win32service.ControlService(s, win32service.SERVICE_CONTROL_CONTINUE) win32service.CloseServiceHandle(s) self.ReloadData()
def Interrogate(self):
serviceHandle = None
try:
serviceHandle = ServiceEntity.__getServiceHandle(self.ServiceName, self.__serviceConfigManagerHandle)
statusValues = win32service.ControlService(serviceHandle, win32service.SERVICE_CONTROL_INTERROGATE)
return ServiceStatusEntity(statusValues).Status
finally:
if serviceHandle:
win32service.CloseServiceHandle(serviceHandle)
def stop(self):
log.info("Trying to stop the winpmem service...")
try:
win32service.ControlService(self.service,
win32service.SERVICE_CONTROL_STOP)
except Exception as e:
raise DetectorError("Unable to stop service: {0}".format(e))
self.wait_status(win32service.SERVICE_STOPPED)
def stop( self ):
state = 0
if (self.hs is not None):
if logger().VERBOSE: logger().log( "[helper] stopping service (handle = 0x%08x).." % self.hs )
try:
state = win32service.ControlService( self.hs, win32service.SERVICE_CONTROL_STOP )
#state = win32serviceutil.StopService( name, machine )[1]
except win32service.error, (hr, fn, msg):
logger().error( "StopService failed: %s (%d)" % (msg, hr) )
state = win32service.QueryServiceStatus( self.hs )[1]
def stop(self):
if self.debug:
print "Trying to stop the winpmem service..."
try:
win32service.ControlService(self.service, win32service.SERVICE_CONTROL_STOP)
except Exception as e:
if self.debug:
print "Unable to stop service: {0}".format(e)
self.wait_status(win32service.SERVICE_STOPPED)
def stop_service(self, name):
"""
Stops a service
"""
try:
hsvc = self.get_service(name)
win32service.ControlService(hsvc,
win32service.SERVICE_CONTROL_STOP)
return True
except win32service.error:
return False
def remove_service(self):
self.session.logging.debug("Removing service %s", self.name)
# Make sure the handle is closed.
self.session.physical_address_space.close()
try:
win32service.ControlService(self.hSvc,
win32service.SERVICE_CONTROL_STOP)
except win32service.error:
pass
win32service.DeleteService(self.hSvc)
win32service.CloseServiceHandle(self.hSvc)
def SvcDoRun(self):
# We do nothing other than wait to be stopped!
win32event.WaitForSingleObject(self.hWaitStop, win32event.INFINITE)
while True:
status = win32service.QueryServiceStatus(self.hs)
type, state = status[0], status[1]
if type not in (win32service.SERVICE_STOP,
win32service.SERVICE_STOP_PENDING):
newstatus = win32service.ControlService(
self.hs, win32service.SERVICE_CONTROL_PAUSE)
def ControlService(serviceName, code, machine = None):
hscm = win32service.OpenSCManager(machine,None,win32service.SC_MANAGER_ALL_ACCESS)
try:
hs = SmartOpenService(hscm, serviceName, win32service.SERVICE_ALL_ACCESS)
try:
status = win32service.ControlService(hs, code)
finally:
win32service.CloseServiceHandle(hs)
finally:
win32service.CloseServiceHandle(hscm)
return status
def start_service(h_svc, logger):
"""Starts the winpmem service"""
# Make sure the service is stopped.
try:
win32service.ControlService(h_svc, win32service.SERVICE_CONTROL_STOP)
except win32service.error:
pass
try:
win32service.StartService(h_svc, [])
except win32service.error, e:
logger.error(str(e) + ": will try to continue")
def stop(self):
""" Stop the service. """
hService = winsvc.OpenService(self.scm_handle, self.ServiceName,
winsvc.SERVICE_STOP)
try:
winsvc.ControlService(hService, winsvc.SERVICE_CONTROL_STOP)
except pywintypes.error, e:
if e.winerror == winerror.ERROR_DEPENDENT_SERVICES_RUNNING:
self.last_error = "%s (%s)" % (e.strerror, ','.join(
self.Dependencies))
else:
self.last_error = e.strerror
def Stop(self):
if self.stopped:
cx_Logging.Info("Service %s already stopped.", self.name)
else:
cx_Logging.Info("Stopping service %s", self.name)
win32service.ControlService(self.handle,
win32service.SERVICE_CONTROL_STOP)
while True:
if self.state != win32service.SERVICE_STOP_PENDING:
break
cx_Logging.Info(" waiting for service to stop....")
time.sleep(2)
def __StopServiceWithTimeout(hs, waitSecs = 30):
try:
status = win32service.ControlService(hs, win32service.SERVICE_CONTROL_STOP)
except pywintypes.error as exc:
if exc.winerror!=winerror.ERROR_SERVICE_NOT_ACTIVE:
raise
for i in range(waitSecs):
status = win32service.QueryServiceStatus(hs)
if status[1] == win32service.SERVICE_STOPPED:
break
win32api.Sleep(1000)
else:
raise pywintypes.error(winerror.ERROR_SERVICE_REQUEST_TIMEOUT, "ControlService", win32api.FormatMessage(winerror.ERROR_SERVICE_REQUEST_TIMEOUT)[:-2])
def __stop_driver(self):
hService = None
hService = win32service.OpenService(self.hSCManager, 'WINIO',
win32service.SERVICE_ALL_ACCESS)
try:
win32service.ControlService(hService,
win32service.SERVICE_CONTROL_STOP)
except pywintypes.error as e:
if e.winerror == EC_SERVICE_NOT_STARTED:
return
else:
raise e
def Stop(self, serviceName):
"""Stop the service."""
print "Stopping service", serviceName
handle = win32service.OpenService(self.__handle, serviceName,
SC_MANAGER_ALL_ACCESS)
win32service.ControlService(handle, SERVICE_CONTROL_STOP)
while True:
state = self.__GetState(handle)
if state != SERVICE_STOP_PENDING:
break
print " waiting for service to stop...."
time.sleep(2)
win32service.CloseServiceHandle(handle)
def Continue(self):
serviceHandle = None
try:
serviceHandle = ServiceEntity.__getServiceHandle(self.ServiceName, self.__serviceConfigManagerHandle)
win32service.ControlService(serviceHandle, win32service.SERVICE_CONTROL_CONTINUE)
start = time.time()
status = self.GetServiceStatus()
while status['CurrentState'].Win32Value() != CurrentStateType.RUNNING:
if time.time() - start > self._TIMEOUT:
raise TimeoutException()
time.sleep(.5)
status = self.GetServiceStatus()
return status
finally:
if serviceHandle:
win32service.CloseServiceHandle(serviceHandle)
def StopService(serviceName):
retval = False
manager = None
service = None
try:
manager = win32service.OpenSCManager('localhost', 'ServicesActive',
win32service.SC_MANAGER_CONNECT)
service = win32service.OpenService(
manager, serviceName,
win32service.SERVICE_STOP | win32service.SERVICE_QUERY_STATUS)
status = win32service.QueryServiceStatus(service)
if status[1] == win32service.SERVICE_STOP_PENDING or status[
1] == win32service.SERVICE_STOPPED:
print(('Service %s is already stopped (%s)' %
(serviceName, GetCurrentStateStr(state)[0])))
else:
print(('Stopping service %s' % serviceName))
if win32service.ControlService(service,
win32service.SERVICE_CONTROL_STOP):
win32api.Sleep(1000)
stopped = False
slept = 0
while not stopped and slept < 5:
status = win32service.QueryServiceStatus(service)
if status[1] == win32service.SERVICE_STOPPED:
stopped = True
else:
win32api.Sleep(500)
slept += 1
retval = True
except Exception as inst:
if len(inst.args) == 3:
number = inst.args[0]
function = inst.args[1]
message = inst.args[2]
print(('ERROR stopping service: %#08x (%s): %s' %
(number, function, message)))
else:
print(('ERROR stopping service: %s' % inst))
finally:
if service:
win32service.CloseServiceHandle(service)
if manager:
win32service.CloseServiceHandle(manager)
return retval
def stop(self):
"""停止服务"""
try:
status_info = win32service.ControlService(self.handle, win32service.SERVICE_CONTROL_STOP)
except Exception as e:
return e
if status_info[1] == win32service.SERVICE_STOPPED:
return '停止服务%s成功!'% self.name
elif status_info[1] == win32service.SERVICE_STOP_PENDING:
start_time = datetime.datetime.now()
while True:
if (datetime.datetime.now() - start_time).seconds > self.delay_time:
return '停止服务%s时间太长!'% self.name
time.sleep(self.wait_time)
if win32service.QueryServiceStatus(self.handle)[1] == win32service.SERVICE_STOPPED:
return '停止服务%s成功!' % self.name
else:
return '停止服务%s失败!'% self.name
async def stop(self):
try:
status_info = win32service.ControlService(
self.handle, win32service.SERVICE_CONTROL_STOP)
except Exception as e:
raise PermissionError("Ошибка остановки сервиса")
if status_info[1] == win32service.SERVICE_STOPPED:
return True
elif status_info[1] == win32service.SERVICE_STOP_PENDING:
start_time = datetime.now()
while True:
if (datetime.now() - start_time).seconds > self.delay_time:
raise TimeoutError("Таймаут остановки сервиса")
time.sleep(2)
if (win32service.QueryServiceStatus(
self.handle)[1] == win32service.SERVICE_STOPPED):
return True
else:
raise PermissionError("Ошибка остановки сервиса")
