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("Ошибка остановки сервиса")