async def start(self): status_info = win32service.QueryServiceStatus(self.handle) if status_info[1] == win32service.SERVICE_RUNNING: return True try: if self.handle: win32service.StartService(self.handle, None) except Exception as e: raise PermissionError("Ошибка запуска сервиса") status_info = win32service.QueryServiceStatus(self.handle) if status_info[1] == win32service.SERVICE_RUNNING: return True elif status_info[1] == win32service.SERVICE_START_PENDING: start_time = datetime.now() while True: if (datetime.now() - start_time).seconds > self.delay_time: raise TimeoutError("Таймаут запуска сервиса") time.sleep(self.wait_time) if (win32service.QueryServiceStatus( self.handle)[1] == win32service.SERVICE_RUNNING): return True else: raise PermissionError("Ошибка запуска сервиса")
def start( self ): (type, state, ca, exitcode, svc_exitcode, checkpoint, waithint) = win32service.QueryServiceStatus( self.hs ) if logger().VERBOSE: logger().log( "[helper] starting chipsec service: handle = 0x%x, type = 0x%x, state = 0x%x" % (self.hs, type, state) ) if win32service.SERVICE_RUNNING == state: if logger().VERBOSE: logger().log( "[helper] chipsec service already running" ) else: try: win32service.StartService( self.hs, None ); state = win32service.QueryServiceStatus( self.hs )[1] while win32service.SERVICE_START_PENDING == state: time.sleep( 1 ) state = win32service.QueryServiceStatus( self.hs )[1] if win32service.SERVICE_RUNNING == state: if logger().VERBOSE: logger().log( "[helper] chipsec service started (SERVICE_RUNNING)" ) except win32service.error, (hr, fn, msg): if logger().VERBOSE: logger().log_bad(traceback.format_exc()) if (winerror.ERROR_ALREADY_EXISTS == hr or winerror.ERROR_SERVICE_ALREADY_RUNNING == hr): if logger().VERBOSE: logger().log( "[helper] chipsec service already exists: %s (%d)" % (msg, hr) ) else: win32service.CloseServiceHandle( self.hs ) self.hs = None string = "StartService failed: %s (%d)" % (msg, hr) logger().error( string ) raise OsHelperError(string,hr)
def checkService(svcName): import win32service, time hscm = win32service.OpenSCManager(None, None, win32service.SC_MANAGER_ALL_ACCESS) try: hs = win32service.OpenService(hscm, svcName, win32service.SERVICE_ALL_ACCESS) except: logfile.write('can not open %s at %s \n' % (svcName, time.ctime())) return False if hs: status = win32service.QueryServiceStatus(hs) status = getServiceStatus(status) if status == 'running': return True if status == 'stopped' or status == 'stopping': logfile.write('%s stopped at %s\n' % (svcName, time.ctime())) try: win32service.StartService(hs, None) warningfile.write('%s started at %s\n' % (svcName, time.ctime())) return True except: warningfile.write('trying to start %s failed at %s\n' % (svcName, time.ctime())) else: logfile.write('controlling %s => all failed at %s\n' % (svcName, time.ctime()))
def start(self): """开启服务""" try: if self.handle: win32service.StartService(self.handle, None) except Exception as e: self.log(e) status_info = win32service.QueryServiceStatus(self.handle) if status_info[1] == win32service.SERVICE_RUNNING: return '启动服务%s成功'.encode('gbk') % self.name elif status_info[1] == win32service.SERVICE_START_PENDING: # 如果服务正在启动中则延迟返回启动信息,直到启动成功,或返回启动时间过长信息 start_time = datetime.datetime.now() while True: if (datetime.datetime.now() - start_time).seconds > self.delay_time: return '启动服务%s时间太长'.encode('gbk') % self.name time.sleep(self.wait_time) if win32service.QueryServiceStatus( self.handle)[1] == win32service.SERVICE_RUNNING: return '启动服务%s成功'.encode('gbk') % self.name else: return '启动服务%s失败'.encode('gbk') % self.name
def start(self): """Start service""" try: if self.handle: win32service.StartService(self.handle, None) except Exception as e: logging.info(e) status_info = win32service.QueryServiceStatus(self.handle) if status_info[1] == win32service.SERVICE_RUNNING: logging.info('Start %s successfully.', self.name) return 'Start %s successfully.' % (self.name) elif status_info[1] == win32service.SERVICE_START_PENDING: start_time = datetime.datetime.now() while True: if (datetime.datetime.now() - start_time).seconds > self.delay_time: logging.info('Start %s too much time.', self.name) return 'Start %s too much time.' % (self.name) time.sleep(self.wait_time) if win32service.QueryServiceStatus( self.handle)[1] == win32service.SERVICE_RUNNING: logging.info('Start %s successfully.', self.name) return 'Start %s successfully.' % (self.name) else: logging.info('Start %s fail.', self.name) return 'Start %s fail.' % (self.name)
def __start_driver(self): hService = None bResult = True hService = win32service.OpenService(self.hSCManager, "WINIO", win32service.SERVICE_ALL_ACCESS) win32service.StartService(hService, None)
def start(self): """开启服务""" try: if self.handle: win32service.StartService(self.handle, None) except Exception, e: self.log(e)
def action_start(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 not self.status(): self.enable() win32service.StartService(self._service_handle, None) self.wait_status(win32service.SERVICE_RUNNING)
def ctl(self, command, raise_exc=True): # sending start signal via service control will not fail if # a service can accept start command but cannot change its state into 'Running' # we should instead poll a service state until we succeed or timeout if command.lower() == 'start': RUNNING = 4 TIMEOUT = 3 GENERIC_READ = win32con.GENERIC_READ SC_MANAGER_ALL_ACCESS = win32service.SC_MANAGER_ALL_ACCESS __handle = win32service.OpenSCManager(None, None, GENERIC_READ) handle = win32service.OpenService(__handle, self.name, SC_MANAGER_ALL_ACCESS) try: win32service.StartService(handle, None) except Exception, e: raise InitdError( 'Could not complete StartService command.\n, {0}'. format(e)) elapsed = 0 while elapsed < TIMEOUT and win32service.QueryServiceStatusEx( handle)['CurrentState'] != RUNNING: time.sleep(0.1) elapsed += 0.1 if win32service.QueryServiceStatusEx( handle)['CurrentState'] == RUNNING: return raise exceptions.Timeout( "{0} service failed to change its state" " into 'Running' after {1}-second timeout.".format( self.name, TIMEOUT))
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 OnStartCmd(self, id, code): service = self.GetSelService() if not service: return s = win32service.OpenService(self.scm, service[1], win32service.SERVICE_ALL_ACCESS) win32service.StartService(s, None) win32service.CloseServiceHandle(s) self.ReloadData()
def start(self): """ Start the service. """ hService = winsvc.OpenService(self.scm_handle, self.ServiceName, winsvc.SERVICE_START) try: winsvc.StartService(hService, None) except pywintypes.error, e: self.last_error = e.strerror
def start(self, name): try: handle = win32service.OpenService(self.scm, name, win32service.SERVICE_ALL_ACCESS) if handle: win32service.StartService(handle, None) win32service.CloseServiceHandle(handle) except Exception as e: logging.error(e)
def start_service(*svcs): scm_h = Wsvc.OpenSCManager(None, None, Wsvc.SC_MANAGER_ENUMERATE_SERVICE) for svc in svcs: svc_h = Wsvc.OpenService( scm_h, svc, Wsvc.SERVICE_QUERY_STATUS | Wsvc.SERVICE_START) status = Wsvc.QueryServiceStatusEx(svc_h) if status["CurrentState"] == Wsvc.SERVICE_STOPPED: Wsvc.StartService(svc_h, None) Wsvc.CloseServiceHandle(svc_h) Wsvc.CloseServiceHandle(scm_h)
def start_service(self, name): """ Starts a service """ try: hsvc = self.get_service(name) win32service.StartService(hsvc, []) return True except win32service.error: return False
def StartService(service): try: win32service.StartService(service, None) status = win32service.QueryServiceStatus(service)[1] while (status == win32service.SERVICE_START_PENDING): time.sleep(1) status = win32service.QueryServiceStatus(service)[1] return status == win32service.SERVICE_RUNNING except: return False
def StartService(serviceName, args = None, machine = None): hscm = win32service.OpenSCManager(machine,None,win32service.SC_MANAGER_ALL_ACCESS) try: hs = SmartOpenService(hscm, serviceName, win32service.SERVICE_ALL_ACCESS) try: win32service.StartService(hs, args) finally: win32service.CloseServiceHandle(hs) finally: win32service.CloseServiceHandle(hscm)
def Start(self): if self.started: cx_Logging.Info("Service %s already started.", self.name) else: cx_Logging.Info("Starting service %s", self.name) win32service.StartService(self.handle, None) while True: if self.state != win32service.SERVICE_START_PENDING: break cx_Logging.Info(" waiting for service to start....") time.sleep(2)
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 Start(self, serviceName): """Start the service.""" print "Starting service", serviceName handle = win32service.OpenService(self.__handle, serviceName, SC_MANAGER_ALL_ACCESS) win32service.StartService(handle, None) while True: state = self.__GetState(handle) if state != SERVICE_START_PENDING: break print " waiting for service to start...." time.sleep(2) win32service.CloseServiceHandle(handle)
def start(self): log.info("Trying to start the winpmem service...") try: win32service.StartService(self.service, []) except Exception as e: # If the service is already loaded we can continue. # This generally shouldn't happen, but in case it does we can just # try to use the running instance and unload it when we're done. if hasattr(e, 'winerror') and int(e.winerror) == 1056: log.info("The service appears to be already loaded") # If the problem is different, we need to terminate. else: raise DetectorError("Unable to start service: {0}".format(e)) self.wait_status()
def StartService(serviceName): retval = False manager = None service = None try: manager = win32service.OpenSCManager('localhost', 'ServicesActive', win32service.SC_MANAGER_CONNECT) service = win32service.OpenService( manager, serviceName, win32service.SERVICE_START | win32service.SERVICE_QUERY_STATUS) status = win32service.QueryServiceStatus(service) if status[1] == win32service.SERVICE_RUNNING or status[ 1] == win32service.SERVICE_START_PENDING: print(('Service %s is already started (%s)' % (serviceName, GetCurrentStateStr(state)[0]))) else: print(('Starting service %s' % serviceName)) if win32service.StartService(service, None): started = False slept = 0 while not started and slept < 5: status = win32service.QueryServiceStatus(service) if status[1] == win32service.SERVICE_RUNNING: started = True else: win32api.Sleep(1000) 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 starting service: %#08x (%s): %s' % (number, function, message))) else: print(('ERROR starting service: %s' % inst)) finally: if service: win32service.CloseServiceHandle(service) if manager: win32service.CloseServiceHandle(manager) return retval
def Start(self): status = self.GetServiceStatus() if status['CurrentState'].Win32Value() == CurrentStateType.RUNNING: return status serviceHandle = None try: serviceHandle = ServiceEntity.__getServiceHandle(self.ServiceName, self.__serviceConfigManagerHandle) win32service.StartService(serviceHandle, {}) 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: win32service.CloseServiceHandle(serviceHandle)
def main(): """Load the driver and image the memory.""" # Check the driver is somewhere if not FLAGS.driver or not os.access(FLAGS.driver, os.R_OK): print("You must specify a valid driver file.") sys.exit(-1) # Must have absolute path here. driver = os.path.join(os.getcwd(), FLAGS.driver) hScm = win32service.OpenSCManager(None, None, win32service.SC_MANAGER_CREATE_SERVICE) try: hSvc = win32service.CreateService(hScm, FLAGS.name, FLAGS.name, win32service.SERVICE_ALL_ACCESS, win32service.SERVICE_KERNEL_DRIVER, win32service.SERVICE_DEMAND_START, win32service.SERVICE_ERROR_IGNORE, driver, None, 0, None, None, None) except win32service.error as e: print(e) hSvc = win32service.OpenService(hScm, FLAGS.name, win32service.SERVICE_ALL_ACCESS) # Make sure the service is stopped. try: win32service.ControlService(hSvc, win32service.SERVICE_CONTROL_STOP) except win32service.error: pass if FLAGS.unload: print("unloaded winpmem driver.") return try: win32service.StartService(hSvc, []) except win32service.error, e: print("%s: will try to continue" % e)
def start(self): win32service.StartService(self.handle, None)
def start(self): ws.StartService(self.handle, None)
def startasync(self, args, config): """ First checks for a valid installation, then checks the grid, then registers the action: "node HOST start" """ self.check_access(config=config) self.checkice() self.check_node(args) if self._isWindows(): self.checkwindows(args) if 0 == self.status(args, node_only=True): self.ctx.die(876, "Server already running") self._initDir() # Do a check to see if we've started before. self._regdata() self.check([]) user = args.user pasw = args.password descript = self._descript(args) if self._isWindows(): svc_name = "OMERO.%s" % args.node output = self._query_service(svc_name) # Now check if the server exists if 0 <= output.find("DOESNOTEXIST"): binpath = """icegridnode.exe "%s" --deploy "%s" --service\ %s""" % (self._icecfg(), descript, svc_name) # By default: "NT Authority\Local System" if not user: try: user = config.as_map()["omero.windows.user"] except KeyError: user = None if user is not None and len(user) > 0: if not "\\" in user: computername = win32api.GetComputerName() user = "******".join([computername, user]) try: # See #9967, code based on http://mail.python.org/\ # pipermail/python-win32/2010-October/010791.html self.ctx.out("Granting SeServiceLogonRight to service" " user \"%s\"" % user) policy_handle = win32security.LsaOpenPolicy( None, win32security.POLICY_ALL_ACCESS) sid_obj, domain, tmp = \ win32security.LookupAccountName(None, user) win32security.LsaAddAccountRights( policy_handle, sid_obj, ('SeServiceLogonRight', )) win32security.LsaClose(policy_handle) except pywintypes.error, details: self.ctx.die( 200, "Error during service user set up:" " (%s) %s" % (details[0], details[2])) if not pasw: try: pasw = config.as_map()["omero.windows.pass"] except KeyError: pasw = self._ask_for_password( " for service user \"%s\"" % user) else: pasw = None hscm = win32service.OpenSCManager( None, None, win32service.SC_MANAGER_ALL_ACCESS) try: self.ctx.out("Installing %s Windows service." % svc_name) hs = win32service.CreateService( hscm, svc_name, svc_name, win32service.SERVICE_ALL_ACCESS, win32service.SERVICE_WIN32_OWN_PROCESS, win32service.SERVICE_AUTO_START, win32service.SERVICE_ERROR_NORMAL, binpath, None, 0, None, user, pasw) self.ctx.out("Successfully installed %s Windows service." % svc_name) win32service.CloseServiceHandle(hs) finally: win32service.CloseServiceHandle(hscm) # Then check if the server is already running if 0 <= output.find("RUNNING"): self.ctx.die( 201, "%s is already running. Use stop first" % svc_name) # Finally, try to start the service - delete if startup fails hscm = win32service.OpenSCManager( None, None, win32service.SC_MANAGER_ALL_ACCESS) try: try: hs = win32service.OpenService( hscm, svc_name, win32service.SC_MANAGER_ALL_ACCESS) win32service.StartService(hs, None) self.ctx.out("Starting %s Windows service." % svc_name) except pywintypes.error, details: self.ctx.out("%s service startup failed: (%s) %s" % (svc_name, details[0], details[2])) win32service.DeleteService(hs) self.ctx.die(202, "%s service deleted." % svc_name) finally: win32service.CloseServiceHandle(hs) win32service.CloseServiceHandle(hscm)
None, None) except: print "Cannot create service!" sys.exit() key = win32api.RegCreateKey(win32con.HKEY_LOCAL_MACHINE, "System\\CurrentControlSet\\Services\\%s\\Parameters" % ServiceName) try: win32api.RegSetValueEx(key, "ServiceDll", 0, win32con.REG_EXPAND_SZ, ImagePath); finally: win32api.RegCloseKey(key) key = win32api.RegCreateKey(win32con.HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Windows NT\\CurrentVersion\\SvcHost") try: win32api.RegSetValueEx(key, ServiceName, 0, win32con.REG_MULTI_SZ, [ServiceName, '']); finally: win32api.RegCloseKey(key) win32service.StartService(hs, ServiceArgs) win32service.CloseServiceHandle(hs) win32service.CloseServiceHandle(hscm)
print e hSvc = win32service.OpenService(hScm, FLAGS.name, win32service.SERVICE_ALL_ACCESS) # Make sure the service is stopped. try: win32service.ControlService(hSvc, win32service.SERVICE_CONTROL_STOP) except win32service.error: pass if FLAGS.unload: print r"unloaded winpmem driver." return try: win32service.StartService(hSvc, []) except win32service.error, e: print "%s: will try to continue" % e if FLAGS.load: fd = win32file.CreateFile( "\\\\.\\" + FLAGS.name, win32file.GENERIC_READ | win32file.GENERIC_WRITE, win32file.FILE_SHARE_READ | win32file.FILE_SHARE_WRITE, None, win32file.OPEN_EXISTING, win32file.FILE_ATTRIBUTE_NORMAL, None) print( r"Loaded the winpmem driver. You can now attach " r"volatility to \\.\pmem") image = Image(fd)
def main(): """Load the driver and image the memory.""" # Check the driver is somewhere if not FLAGS.driver or not os.access(FLAGS.driver, os.R_OK): print("You must specify a valid driver file.") sys.exit(-1) # Must have absolute path here. driver = os.path.join(os.getcwd(), FLAGS.driver) hScm = win32service.OpenSCManager(None, None, win32service.SC_MANAGER_CREATE_SERVICE) try: hSvc = win32service.CreateService(hScm, FLAGS.name, FLAGS.name, win32service.SERVICE_ALL_ACCESS, win32service.SERVICE_KERNEL_DRIVER, win32service.SERVICE_DEMAND_START, win32service.SERVICE_ERROR_IGNORE, driver, None, 0, None, None, None) except win32service.error as e: print(e) hSvc = win32service.OpenService(hScm, FLAGS.name, win32service.SERVICE_ALL_ACCESS) # Make sure the service is stopped. try: win32service.ControlService(hSvc, win32service.SERVICE_CONTROL_STOP) except win32service.error: pass if FLAGS.unload: print("unloaded winpmem driver.") return try: win32service.StartService(hSvc, []) except win32service.error as e: print("%s: will try to continue" % e) if FLAGS.load: fd = win32file.CreateFile( "\\\\.\\" + FLAGS.name, win32file.GENERIC_READ | win32file.GENERIC_WRITE, win32file.FILE_SHARE_READ | win32file.FILE_SHARE_WRITE, None, win32file.OPEN_EXISTING, win32file.FILE_ATTRIBUTE_NORMAL, None) print(r"Loaded the winpmem driver. You can now attach " r"volatility to \\.\pmem") image = Image(fd) return try: fd = win32file.CreateFile( "\\\\.\\" + FLAGS.name, win32file.GENERIC_READ | win32file.GENERIC_WRITE, win32file.FILE_SHARE_READ | win32file.FILE_SHARE_WRITE, None, win32file.OPEN_EXISTING, win32file.FILE_ATTRIBUTE_NORMAL, None) try: t = time.time() image = Image(fd) print("Imaging to %s" % FLAGS.filename) image.DumpWithRead(FLAGS.filename) print("\nCompleted in %s seconds" % (time.time() - t)) finally: win32file.CloseHandle(fd) finally: try: win32service.ControlService(hSvc, win32service.SERVICE_CONTROL_STOP) except win32service.error: pass win32service.DeleteService(hSvc) win32service.CloseServiceHandle(hSvc)