def stop(self, pid): # call the method that any subclasses out there may implement: self.onStop() winver = sys.getwindowsversion() # This is unfortunately needed because runzope.exe is a setuptools # generated .exe that spawns off a sub process, so pid would give us # the wrong event name. child_pid = int( open(self.getReg('pid_filename', keyname='PythonClass')).read()) # Stop the child process by sending signals to the special named event. # We give it 90 seconds to shutdown normally. If that doesn't stop # things, we give it 30 seconds to do a "fast" shutdown. for sig, timeout in ( (signal.SIGINT, 30), (signal.SIGTERM, 10)): # See the Signals.WinSignalHandler module for # the source of this event name event_name = "Zope-%d-%d" % (child_pid, sig) if winver[0] >= 5 and winver[3] == 2: event_name = "Global\\" + event_name try: he = win32event.OpenEvent(win32event.EVENT_MODIFY_STATE, 0, event_name) except win32event.error: # no other expected error - report it. self.warning("Failed to open child shutdown event %s" % (event_name, )) continue win32event.SetEvent(he) # It should be shutting down now - wait for termination, reporting # progress as we go. for i in range(timeout): # wait for one second rc = win32event.WaitForSingleObject(self.hZope, 1000) if rc == win32event.WAIT_OBJECT_0: break # Process terminated - no need to try harder. if rc == win32event.WAIT_OBJECT_0: break if win32process.GetExitCodeProcess(self.hZope)==win32con.STILL_ACTIVE: # None of the signals worked, so kill the process self.warning( "Terminating process as it could not be gracefully ended") win32api.TerminateProcess(self.hZope, 3) output = self.getCapturedOutput() if output: self.info("Process terminated with output:\n"+output)
def terminate(self): ''' Terminates the process ''' try: win32api.TerminateProcess(self._handle, 1) except OSError: # ERROR_ACCESS_DENIED (winerror 5) is received when the # process already died. ecode = win32process.GetExitCodeProcess(self._handle) if ecode == win32con.STILL_ACTIVE: raise self.exitstatus = ecode
def runAsAdmin(cmdLine=None, wait=True): if os.name != 'nt': # raise RuntimeError, "This function is only implemented on Windows." raise Exception("RuntimeError", "This function is only implemented on Windows.") # import win32api, win32con, win32event, win32process import win32con, win32event, win32process from win32com.shell.shell import ShellExecuteEx from win32com.shell import shellcon python_exe = sys.executable if cmdLine is None: cmdLine = [python_exe] + sys.argv elif type(cmdLine) not in (types.TupleType, types.ListType): # raise ValueError, "cmdLine is not a sequence." raise Exception("ValueError", "cmdLine is not a sequence.") cmd = '"%s"' % (cmdLine[0], ) # XXX TODO: isn't there a function or something we can call to massage command line params? params = " ".join(['"%s"' % (x, ) for x in cmdLine[1:]]) # cmdDir = '' showCmd = win32con.SW_SHOWNORMAL # showCmd = win32con.SW_HIDE lpVerb = 'runas' # causes UAC elevation prompt. # print "Running", cmd, params # ShellExecute() doesn't seem to allow us to fetch the PID or handle # of the process, so we can't get anything useful from it. Therefore # the more complex ShellExecuteEx() must be used. # procHandle = win32api.ShellExecute(0, lpVerb, cmd, params, cmdDir, showCmd) procInfo = ShellExecuteEx(nShow=showCmd, fMask=shellcon.SEE_MASK_NOCLOSEPROCESS, lpVerb=lpVerb, lpFile=cmd, lpParameters=params) if wait: procHandle = procInfo['hProcess'] # obj = win32event.WaitForSingleObject(procHandle, win32event.INFINITE) win32event.WaitForSingleObject(procHandle, win32event.INFINITE) rc = win32process.GetExitCodeProcess(procHandle) # print "Process handle %s returned code %s" % (procHandle, rc) else: rc = None return rc
def start(self): """ Starts the process and the logger pipes for its stdout and stderr. """ creation_flags = 0 if sys.platform == "win32" and _JOB_OBJECT is not None: creation_flags |= win32process.CREATE_BREAKAWAY_FROM_JOB # Use unbuffered I/O pipes to avoid adding delay between when the subprocess writes output # and when the LoggerPipe thread reads it. buffer_size = 0 # Close file descriptors in the child process before executing the program. This prevents # file descriptors that were inherited due to multiple calls to fork() -- either within one # thread, or concurrently from multiple threads -- from causing another subprocess to wait # for the completion of the newly spawned child process. Closing other file descriptors # isn't supported on Windows when stdout and stderr are redirected. close_fds = (sys.platform != "win32") with _POPEN_LOCK: self._process = subprocess.Popen(self.args, bufsize=buffer_size, stdout=subprocess.PIPE, stderr=subprocess.PIPE, close_fds=close_fds, env=self.env, creationflags=creation_flags) self.pid = self._process.pid self._stdout_pipe = pipe.LoggerPipe(self.logger, logging.INFO, self._process.stdout) self._stderr_pipe = pipe.LoggerPipe(self.logger, logging.ERROR, self._process.stderr) self._stdout_pipe.wait_until_started() self._stderr_pipe.wait_until_started() if sys.platform == "win32" and _JOB_OBJECT is not None: try: win32job.AssignProcessToJobObject(_JOB_OBJECT, self._process._handle) except win32job.error as err: # ERROR_ACCESS_DENIED (winerror=5) is received when the process has already died. if err.winerror != winerror.ERROR_ACCESS_DENIED: raise return_code = win32process.GetExitCodeProcess( self._process._handle) if return_code == win32con.STILL_ACTIVE: raise
def RunAsAdmin(conn=None, cmdLine=None, showCmd=False, wait=True): if os.name != 'nt': raise (RuntimeError, "This function is only implemented on Windows.") if cmdLine is None: python_exe = sys.executable cmdLine = [python_exe] + sys.argv else: try: #check if list/tuple ",".join(cmdLine) print(cmdLine[0]) except: raise Exception(TypeError, cmdLine, "cmdLine is not a list or a tuple type") cmd = cmdLine[0] params = " ".join([x for x in cmdLine[1:]]) #show shell or keep it hidden if showCmd is True: showCmd = win32con.SW_SHOWNORMAL elif showCmd is False: showCmd = win32con.SW_HIDE else: raise Exception(ArgError, "showCmd: Invalid value - ", showCmd) lpVerb = 'runas' # causes UAC elevation prompt. procInfo = ShellExecuteEx(nShow=showCmd, fMask=shellcon.SEE_MASK_NOCLOSEPROCESS, lpVerb=lpVerb, lpFile=cmd, lpParameters=params) # cmd+= " " +params # procHandle, threadHandle, procId, threadId = DoCreateProcess(cmd) if conn: pass conn.put("") if wait: procHandle = procInfo['hProcess'] # print ("pr",prponerocHandle obj = win32event.WaitForSingleObject(procHandle, win32event.INFINITE) rc = win32process.GetExitCodeProcess(procHandle) print("Process handle %s returned code %s" % (procHandle, rc)) else: rc = None return rc
def run_as_admin(file, params): #SEE_MASK_NO_CONSOLE = 0x00008000 SEE_MASK_NOCLOSEPROCESS = 0x00000040 SHOWNORMAL = 1 procInfo = shell.ShellExecuteEx(lpVerb='runas', lpFile=file, lpParameters=params, nShow=SHOWNORMAL, fMask=SEE_MASK_NOCLOSEPROCESS) procHandle = procInfo['hProcess'] obj = win32event.WaitForSingleObject(procHandle, win32event.INFINITE) rc = win32process.GetExitCodeProcess(procHandle) print "Process handle %s returned code %s" % (procHandle, rc) return rc
def start(self): """Start the process and the logger pipes for its stdout and stderr.""" creation_flags = 0 if sys.platform == "win32" and _JOB_OBJECT is not None: creation_flags |= win32process.CREATE_BREAKAWAY_FROM_JOB # Tests fail if a process takes too long to startup and listen to a socket. Use buffered # I/O pipes to give the process some leeway. buffer_size = 1024 * 1024 # Close file descriptors in the child process before executing the program. This prevents # file descriptors that were inherited due to multiple calls to fork() -- either within one # thread, or concurrently from multiple threads -- from causing another subprocess to wait # for the completion of the newly spawned child process. Closing other file descriptors # isn't supported on Windows when stdout and stderr are redirected. close_fds = (sys.platform != "win32") with _POPEN_LOCK: self._process = subprocess.Popen( self.args, bufsize=buffer_size, stdout=subprocess.PIPE, stderr=subprocess.PIPE, close_fds=close_fds, env=self.env, creationflags=creation_flags, cwd=self._cwd) self.pid = self._process.pid # TODO: check path exists if _config.UNDO_RECORDER_PATH is not None and ("mongod" in self.args[0] or "mongos" in self.args[0]): recorder_args = [ _config.UNDO_RECORDER_PATH, "--thread-fuzzing", "-p", str(self.pid) ] self._recorder = subprocess.Popen(recorder_args, bufsize=buffer_size, env=self.env, creationflags=creation_flags) self._stdout_pipe = pipe.LoggerPipe(self.logger, logging.INFO, self._process.stdout) self._stderr_pipe = pipe.LoggerPipe(self.logger, logging.ERROR, self._process.stderr) self._stdout_pipe.wait_until_started() self._stderr_pipe.wait_until_started() if sys.platform == "win32" and _JOB_OBJECT is not None: try: win32job.AssignProcessToJobObject(_JOB_OBJECT, self._process._handle) except win32job.error as err: # ERROR_ACCESS_DENIED (winerror=5) is received when the process has already died. if err.winerror != winerror.ERROR_ACCESS_DENIED: raise return_code = win32process.GetExitCodeProcess(self._process._handle) if return_code == win32con.STILL_ACTIVE: raise
def Wait(self) -> int: """Waits for the process to exit. Returns: The exit code. Raises: Error: on system error. """ res = win32event.WaitForSingleObject(self._handle, win32event.INFINITE) if res == win32event.WAIT_FAILED: raise Error("WaitForSingleObject failed.") exit_code = win32process.GetExitCodeProcess(self._handle) self._exit_stack.close() return exit_code
def _kill(self): """ Wrapper for os.kill to emulate kill if not on unix. """ if sys.platform in ("win32"): import win32process if self._handle.handle > 0 and win32process.GetExitCodeProcess(self._handle) > 1: import win32api win32api.TerminateProcess(self._handle, 0) self._handle.Close() self._pid = None else: import signal os.kill(self._pid, signal.SIGTERM) self._pid = None
def runAsAdmin(cmd_line=None, wait=True, console=True): # TODO: complete description """ Elevates a new python console window to Administrator. 1- cmd_line: 2- wait : 3- cmd : Sets whether the python console should show it's window. It shows the window by default. : True = shows the elevated python console window. : False or None = does not show the elevated python console window. """ if os.name != 'nt': raise RuntimeError("This function is only implemented on Windows.\n") python_exe = sys.executable if cmd_line is None: cmd_line = [python_exe] + sys.argv # cmd_line = [cmd, params] elif type(cmd_line) not in (types.TupleType, types.ListType): raise ValueError("cmd_line is not a sequence.\n") cmd = '"%s"' % (cmd_line[0], ) # The path of the cmd window # TODO: isn't there a function or something we can call to massage command line params? params = " ".join(['"%s"' % (x, ) for x in cmd_line[1:] ]) # The path of the python script that called if console is False: show_cmd = win32con.SW_HIDE else: show_cmd = win32con.SW_SHOWNORMAL # ShellExecute() doesn't seem to allow us to fetch the PID or handle of the process, so we can't get anything # useful from it. Therefore the more complex ShellExecuteEx() must be used. # NOTE: lpVerb='runas' causes UAC elevation prompt. procInfo = ShellExecuteEx(nShow=show_cmd, fMask=shellcon.SEE_MASK_NOCLOSEPROCESS, lpVerb='runas', lpFile=cmd, lpParameters=params) if wait: procHandle = procInfo['hProcess'] obj = win32event.WaitForSingleObject( procHandle, win32event.INFINITE) # TODO: Necessary? rc = win32process.GetExitCodeProcess(procHandle) else: rc = None return rc
def runAsAdmin(cmdLine=None, wait=True): """Attempt to relaunch the current script as an admin using the same command line parameters. Pass cmdLine in to override and set a new command. It must be a list of [command, arg1, arg2...] format. Set wait to False to avoid waiting for the sub-process to finish. You will not be able to fetch the exit code of the process if wait is False. Returns the sub-process return code, unless wait is False in which case it returns None. @WARNING: this function only works on Windows. """ if os.name != 'nt': raise RuntimeError("This function is only implemented on Windows.") import win32con import win32process from win32com.shell.shell import ShellExecuteEx from win32com.shell import shellcon python_exe = sys.executable if cmdLine is None: cmdLine = [python_exe] + sys.argv elif type(cmdLine) not in (types.TupleType, types.ListType): raise ValueError("cmdLine is not a sequence.") cmd = '"%s"' % (cmdLine[0],) # XXX TODO: isn't there a function or something we can call to # massage command line params? params = " ".join(['"%s"' % (x,) for x in cmdLine[1:]]) showCmd = win32con.SW_SHOWNORMAL lpVerb = 'runas' # causes UAC elevation prompt. procInfo = ShellExecuteEx(nShow=showCmd, fMask=shellcon.SEE_MASK_NOCLOSEPROCESS, lpVerb=lpVerb, lpFile=cmd, lpParameters=params) if wait: procHandle = procInfo['hProcess'] # obj = win32event.WaitForSingleObject(procHandle, win32event.INFINITE) rc = win32process.GetExitCodeProcess(procHandle) else: rc = None return rc
def run_command_win32(cmd): sa = win32security.SECURITY_ATTRIBUTES() sa.bInheritHandle = True stdout_r, stdout_w = win32pipe.CreatePipe(sa, 0) si = win32process.STARTUPINFO() si.dwFlags = (win32process.STARTF_USESTDHANDLES | win32process.STARTF_USESHOWWINDOW) si.wShowWindow = win32con.SW_HIDE si.hStdOutput = stdout_w process, thread, pid, tid = \ win32process.CreateProcess(None, cmd, None, None, True, 0, None, None, si) if process == None: return -1, "" # Must close the write handle in this process, or ReadFile will hang. stdout_w.Close() # Read the pipe until we get an error (including ERROR_BROKEN_PIPE, # which is okay because it happens when child process ends). data = "" error = 0 while 1: try: hr, buffer = win32file.ReadFile(stdout_r, 4096) if hr != winerror.ERROR_IO_PENDING: data = data + buffer except pywintypes.error as e: if e.args[0] != winerror.ERROR_BROKEN_PIPE: error = 1 break if error: return -2, "" # Everything is okay --- the called process has closed the pipe. # For safety, check that the process ended, then pick up its exit code. win32event.WaitForSingleObject(process, win32event.INFINITE) if win32process.GetExitCodeProcess(process): return -3, "" global debug if debug: sys.stdout.write(data) return 0, data
def run_as(self, command): # Importing these only on windows, as they won't exist on linux. import win32api import win32event import win32process from winsys import _advapi32 exit_code = -1 process_handle = None thread_handle = None try: # Open process as that user # https://github.com/tjguk/winsys/blob/master/winsys/_advapi32.py proc_info = _advapi32.CreateProcessWithLogonW( username=self.username, domain=".", password=self.password, command_line=command) process_handle = proc_info.hProcess thread_handle = proc_info.hThread logger.debug("Waiting for process to finish. Timeout: {}ms".format( WAIT_TIMEOUT_IN_MILLISECONDS)) # https://social.msdn.microsoft.com/Forums/vstudio/en-US/b6d6a7ae-71e9-4edb-ac8f # -408d2a41750d/what-events-on-a-process-handle-signal-satisify-waitforsingleobject # ?forum=vcgeneral # Ignoring return code, as we'll use `GetExitCode` to determine the state of the # process later. _ = win32event.WaitForSingleObject( # Waits until the specified object is signaled, or time-out. process_handle, # Ping process handle WAIT_TIMEOUT_IN_MILLISECONDS, # Timeout in milliseconds ) exit_code = win32process.GetExitCodeProcess(process_handle) finally: try: if process_handle is not None: win32api.CloseHandle(process_handle) if thread_handle is not None: win32api.CloseHandle(thread_handle) except Exception as err: logger.error("Close handle error: " + str(err)) return exit_code
def is_process_active(pid): """ @param pid long @return bool """ ret = False try: h = win32api.OpenProcess(win32con.PROCESS_QUERY_INFORMATION, False, pid) if h: status = win32process.GetExitCodeProcess(h) ret = status == win32con.STILL_ACTIVE win32api.CloseHandle(h) except: pass #except Exception, e: dwarn(e) return ret
def force_elevated(): try: if sys.argv[-1] != 'asadmin': script = os.path.abspath(sys.argv[0]) params = ' '.join(["\"%s\"" % script] + sys.argv[1:] + ['asadmin']) procInfo = shell.ShellExecuteEx(nShow=win32con.SW_SHOWNORMAL, fMask=shellcon.SEE_MASK_NOCLOSEPROCESS, lpVerb='runas', lpFile=sys.executable, lpParameters=params) procHandle = procInfo['hProcess'] obj = win32event.WaitForSingleObject(procHandle, win32event.INFINITE) rc = win32process.GetExitCodeProcess(procHandle) except Exception as ex: print ex
def install_pyside_windows(self, python_executable): """Install PySide2 python module to blender's python. Installation requires administration rights that's why it is required to use "pywin32" module which can execute command's and ask for administration rights. """ try: import win32api import win32con import win32process import win32event import pywintypes from win32comext.shell.shell import ShellExecuteEx from win32comext.shell import shellcon except Exception: self.log.warning("Couldn't import \"pywin32\" modules") return try: # Parameters # - use "-m pip" as module pip to install PySide2 and argument # "--ignore-installed" is to force install module to blender's # site-packages and make sure it is binary compatible parameters = "-m pip install --ignore-installed PySide2" # Execute command and ask for administrator's rights process_info = ShellExecuteEx( nShow=win32con.SW_SHOWNORMAL, fMask=shellcon.SEE_MASK_NOCLOSEPROCESS, lpVerb="runas", lpFile=python_executable, lpParameters=parameters, lpDirectory=os.path.dirname(python_executable)) process_handle = process_info["hProcess"] obj = win32event.WaitForSingleObject(process_handle, win32event.INFINITE) returncode = win32process.GetExitCodeProcess(process_handle) if returncode == 0: self.log.info( "Successfully installed PySide2 module to blender.") return except pywintypes.error: pass self.log.warning("Failed to instal PySide2 module to blender.")
def close(self): if self.file: self.file.close() self.file = None if sys.platform == "win32": win32event.WaitForMultipleObjects(self.wait_for, 1, win32event.INFINITE) return win32process.GetExitCodeProcess(self.child_pid) else: if self.thread: self.thread.join() if type(self.child_pid) == type([]): for pid in self.child_pid: exit = os.waitpid(pid, 0)[1] return exit else: return os.waitpid(self.child_pid, 0)[1] return None
def run_as_admin(*cmd_line, wait=True): verb = "runas" if not cmd_line: cmd_line = [sys.executable] + sys.argv cmd = cmd_line[0] params = " ".join(str(x) for x in cmd_line[1:]) process_info = ShellExecuteEx(nShow=win32con.SW_SHOWNORMAL, fMask=shellcon.SEE_MASK_NOCLOSEPROCESS, lpVerb=verb, lpFile=cmd, lpParameters=params) if wait: process_handle = process_info['hProcess'] win32event.WaitForSingleObject(process_handle, win32event.INFINITE) return_code = win32process.GetExitCodeProcess(process_handle) else: return_code = None return return_code
def call(self, method, args): """ Launch program to consume file @type method: string @param method: Command to execute @type args: array of objects @param args: Arguments to pass """ hProcess, hThread, dwProcessId, dwThreadId = win32process.CreateProcess( None, self.commandLine, None, None, 0, win32con.NORMAL_PRIORITY_CLASS, None, None, None) while win32process.GetExitCodeProcess(hProcess) == win32con.STILL_ACTIVE: time.sleep(0.25) self.closeApp(hProcess, self._windowName)
def read_loop(self): while True: if not self.isalive(self.host_process): logger.info('Host process has been died.') return self.child_exitstatus = win32process.GetExitCodeProcess( self.__childProcess) if self.child_exitstatus != win32con.STILL_ACTIVE: logger.info( f'Child finished with code: {self.child_exitstatus}') return consinfo = self.consout.GetConsoleScreenBufferInfo() cursorPos = consinfo['CursorPosition'] if cursorPos.Y > maxconsoleY: '''If the console output becomes long, we suspend the child, read all output then clear the console before we resume the child. ''' logger.info('cursorPos %s' % cursorPos) self.suspend_child() time.sleep(.2) self.send_to_host(self.readConsoleToCursor()) self.refresh_console() self.resume_child() else: self.send_to_host(self.readConsoleToCursor()) s = self.get_from_host() if s: logger.debug(f'get_from_host: {s}') else: logger.spam(f'get_from_host: {s}') if self.enable_signal_chars: for sig, char in SIGNAL_CHARS.items(): if char in s: self.child_process.send_signal(sig) s = s.decode() self.write(s) time.sleep(.02)
def run_vbox_installer_windows(cmd): cmd_dir = '' showCmd = win32con.SW_SHOWNORMAL lpVerb = 'runas' cmd = cmd.split(" ") installer = cmd[0] args = " ".join(cmd[1:]) procInfo = ShellExecuteEx(nShow=showCmd, fMask=shellcon.SEE_MASK_NOCLOSEPROCESS, lpVerb=lpVerb, lpFile=installer, lpParameters=args) procHandle = procInfo['hProcess'] obj = win32event.WaitForSingleObject(procHandle, win32event.INFINITE) rc = win32process.GetExitCodeProcess(procHandle) # print "Process handle %s returned code %s" % (procHandle, rc) log.debug("Virtualbox setup finished") return rc
def ShutdownProcess(process_id, timeout, force=False): """Attempts to nicely close the specified process. Returns the exit code on success. Raises an error on failure. """ # Open the process in question, so we can wait for it to exit. permissions = win32con.SYNCHRONIZE | win32con.PROCESS_QUERY_INFORMATION process_handle = win32api.OpenProcess(permissions, False, process_id) # Loop around to periodically retry to close Chrome. started = time.time() elapsed = 0 while True: _LOGGER.debug('Shutting down process with PID=%d.', process_id) with open(os.devnull, 'w') as f: cmd = ['taskkill.exe', '/PID', str(process_id)] if force: cmd.append('/F') subprocess.call(cmd, shell=True, stdout=f, stderr=f) # Wait at most 2 seconds after each call to taskkill. curr_timeout_ms = int(max(2, timeout - elapsed) * 1000) _LOGGER.debug('Waiting for process with PID=%d to exit.', process_id) result = win32event.WaitForSingleObject(process_handle, curr_timeout_ms) # Exit the loop on successful wait. if result == win32event.WAIT_OBJECT_0: break elapsed = time.time() - started if elapsed > timeout: _LOGGER.debug('Timeout waiting for process to exit.') raise TimeoutException() exit_status = win32process.GetExitCodeProcess(process_handle) process_handle.Close() _LOGGER.debug('Process exited with status %d.', exit_status) return exit_status
def reqadminwin(): import ctypes, win32com.shell.shell, win32event, win32process outpath = r'%s\%s.out' % (os.environ["TEMP"], os.path.basename(__file__)) if ctypes.windll.shell32.IsUserAnAdmin(): if os.path.isfile(outpath): sys.stderr = sys.stdout = open(outpath, 'w', 0) return with open(outpath, 'w+', 0) as outfile: hProc = win32com.shell.shell.ShellExecuteEx(lpFile=sys.executable, \ lpVerb='runas', lpParameters=' '.join(sys.argv), fMask=64, nShow=0)['hProcess'] while True: hr = win32event.WaitForSingleObject(hProc, 40) while True: line = outfile.readline() if not line: break sys.stdout.write(line) if hr != 0x102: break os.remove(outpath) sys.stderr = '' sys.exit(win32process.GetExitCodeProcess(hProc))
def my_spawn(sh, escape, cmd, args, spawnenv): for var in spawnenv: spawnenv[var] = spawnenv[var].encode('ascii', 'replace') sAttrs = win32security.SECURITY_ATTRIBUTES() StartupInfo = win32process.STARTUPINFO() newargs = ' '.join(map(escape, args[1:])) cmdline = cmd + " " + newargs # check for any special operating system commands if cmd == 'del': for arg in args[1:]: win32file.DeleteFile(arg) exit_code = 0 else: # otherwise execute the command. hProcess, hThread, dwPid, dwTid = win32process.CreateProcess(None, cmdline, None, None, 1, 0, spawnenv, None, StartupInfo) win32event.WaitForSingleObject(hProcess, win32event.INFINITE) exit_code = win32process.GetExitCodeProcess(hProcess) win32file.CloseHandle(hProcess); win32file.CloseHandle(hThread); return exit_code
def process_exists(pid): try: if USE_PROCESS_QUERY_LIMITED_INFORMATION: #this one potentially works even for other user's processes h = win32api.OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, 0, pid) else: h = win32api.OpenProcess(win32con.PROCESS_QUERY_INFORMATION, 0, pid) except pywintypes.error as e: if e.winerror == winerror.ERROR_INVALID_PARAMETER: #This error is returned if the pid doesn't match any known process return False elif e.winerror == winerror.ERROR_ACCESS_DENIED: raise AccessDeniedError(e) #Other errors are not expected raise try: exitcode = win32process.GetExitCodeProcess(h) return exitcode == win32con.STILL_ACTIVE finally: win32api.CloseHandle(h)
def setExitStatus(self): """Method to set the exit status of the process. """ with self.__lock: if self.exitStatus is not None: return self.exitStatus exitStatus = win32process.GetExitCodeProcess(self.__hProcess) if exitStatus != win32con.STILL_ACTIVE: try: if self.__hProcess: win32file.CloseHandle(self.__hProcess) if self.__hThread: win32file.CloseHandle(self.__hThread) if self.__stdin: win32file.CloseHandle(self.__stdin) except Exception as e: # these failed sometimes with 'handle is invalid', probably due to interference of stdin writer thread log.warning('Could not close process and thread handles for process %s: %s', self.pid, e) self.__stdin = self.__hThread = self.__hProcess = None self._outQueue = None self.exitStatus = exitStatus return self.exitStatus
def eof(self): ### should be calling file.eof() here instead of file.close(), there ### may be data in the pipe or buffer after the process exits if sys.platform == "win32": r = win32event.WaitForMultipleObjects(self.wait_for, 1, 0) if r == win32event.WAIT_OBJECT_0: self.file.close() self.file = None return win32process.GetExitCodeProcess(self.child_pid) return None if self.thread and self.thread.isAlive(): return None pid, status = os.waitpid(self.child_pid, os.WNOHANG) if pid: self.file.close() self.file = None return status return None
def run_os_command_impersonated(cmd, user, password, domain='.'): si = win32process.STARTUPINFO() out_handle, err_handle, out_file, err_file = _create_tmp_files() ok, si.hStdInput = _safe_duplicate_handle( win32api.GetStdHandle(win32api.STD_INPUT_HANDLE)) if not ok: raise Exception("Unable to create StdInput for child process") ok, si.hStdOutput = _safe_duplicate_handle(out_handle) if not ok: raise Exception("Unable to create StdOut for child process") ok, si.hStdError = _safe_duplicate_handle(err_handle) if not ok: raise Exception("Unable to create StdErr for child process") si.dwFlags = win32process.STARTF_USESTDHANDLES si.lpDesktop = "" user_token = win32security.LogonUser(user, domain, password, win32con.LOGON32_LOGON_SERVICE, win32con.LOGON32_PROVIDER_DEFAULT) primary_token = win32security.DuplicateTokenEx( user_token, win32security.SecurityImpersonation, 0, win32security.TokenPrimary) info = win32process.CreateProcessAsUser(primary_token, None, cmd, None, None, 1, 0, None, None, si) hProcess, hThread, dwProcessId, dwThreadId = info hThread.Close() try: win32event.WaitForSingleObject(hProcess, win32event.INFINITE) except KeyboardInterrupt: pass out, err = _get_files_output(out_file, err_file) exitcode = win32process.GetExitCodeProcess(hProcess) return exitcode, out, err
def enumCallback(hwnd, windowName): """ Will get called by win32gui.EnumWindows, once for each top level application window. """ try: # Get window title title = win32gui.GetWindowText(hwnd) # Is this our guy? if title.find(windowName) == -1: return (threadId, processId) = win32process.GetWindowThreadProcessId(hwnd) # Send WM_CLOSE message try: win32gui.PostMessage(hwnd, win32con.WM_CLOSE, 0, 0) win32gui.PostQuitMessage(hwnd) except: pass # Give it upto 5 sec for i in range(100): if win32process.GetExitCodeProcess( processId) != win32con.STILL_ACTIVE: # Process exited already return time.sleep(0.25) try: # Kill application win32process.TerminateProcess(processId, 0) except: pass except: pass
def runAsAdmin(self, cmdLine=None, wait=True): """ Executes the file again as admin. """ python_exe = sys.executable cmdLine = [python_exe] + sys.argv cmd = '"%s"' % (cmdLine[0], ) params = CHANGE_PASSWORD_FILE + self.password.text cmdDir = '' showCmd = win32con.SW_SHOWNORMAL lpVerb = 'runas' procInfo = ShellExecuteEx(nShow=showCmd, fMask=shellcon.SEE_MASK_NOCLOSEPROCESS, lpVerb=lpVerb, lpFile=cmd, lpParameters=params) procHandle = procInfo['hProcess'] obj = win32event.WaitForSingleObject(procHandle, win32event.INFINITE) rc = win32process.GetExitCodeProcess(procHandle)