_fields_ = [("cb", DWORD),

("lpReserved", LPCWSTR),

("lpDesktop", LPCWSTR),

("lpTitle", LPCWSTR),

("dwX", DWORD),

("dwY", DWORD),

("dwXSize", DWORD),

("dwYSize", DWORD),

("dwXCountChars", DWORD),

("dwYCountChars", DWORD),

("dwFillAttribute", DWORD),

("dwFlags", DWORD),

("wShowWindow", WORD),

("cbReserved2", WORD),

("lpReserved2", LPVOID),

("hStdInput", HANDLE),

("hStdOutput", HANDLE),

_fields_ = [("hProcess", HANDLE),

("hThread", HANDLE),

("dwProcessId", DWORD),

"""A context manager to protect command execution from UNC paths.

def __enter__(self):

self.path = os.getcwdu()

self.is_unc_path = self.path.startswith(r"\\")

if self.is_unc_path:

# change to c drive (as cmd.exe cannot handle UNC addresses)

os.chdir("C:")

return self.path

else:

# We return None to signal that there was no change in the working

# directory

return None

def __exit__(self, exc_type, exc_value, traceback):

if self.is_unc_path:

"""Runs a shell command in a 'with' context.

def __init__(self, cmd, mergeout = True):

"""Initializes the shell command controller.

self.cmd = cmd

self.mergeout = mergeout

def __enter__(self):

cmd = self.cmd

mergeout = self.mergeout

self.hstdout, self.hstdin, self.hstderr = None, None, None

self.piProcInfo = None

try:

p_hstdout, c_hstdout, p_hstderr, \

c_hstderr, p_hstdin, c_hstdin = [None]*6

# SECURITY_ATTRIBUTES with inherit handle set to True

saAttr = SECURITY_ATTRIBUTES()

saAttr.nLength = ctypes.sizeof(saAttr)

saAttr.bInheritHandle = True

saAttr.lpSecurityDescriptor = None

def create_pipe(uninherit):

"""Creates a Windows pipe, which consists of two handles.

handles = HANDLE(), HANDLE()

if not CreatePipe(ctypes.byref(handles[0]),

ctypes.byref(handles[1]), ctypes.byref(saAttr), 0):

raise ctypes.WinError()

if not SetHandleInformation(handles[uninherit],

HANDLE_FLAG_INHERIT, 0):

raise ctypes.WinError()

return handles[0].value, handles[1].value

p_hstdout, c_hstdout = create_pipe(uninherit=0)

# 'mergeout' signals that stdout and stderr should be merged.

# We do that by using one pipe for both of them.

if mergeout:

c_hstderr = HANDLE()

if not DuplicateHandle(GetCurrentProcess(), c_hstdout,

GetCurrentProcess(), ctypes.byref(c_hstderr),

0, True, DUPLICATE_SAME_ACCESS):

raise ctypes.WinError()

else:

p_hstderr, c_hstderr = create_pipe(uninherit=0)

c_hstdin, p_hstdin = create_pipe(uninherit=1)

# Create the process object

piProcInfo = PROCESS_INFORMATION()

siStartInfo = STARTUPINFO()

siStartInfo.cb = ctypes.sizeof(siStartInfo)

siStartInfo.hStdInput = c_hstdin

siStartInfo.hStdOutput = c_hstdout

siStartInfo.hStdError = c_hstderr

siStartInfo.dwFlags = STARTF_USESTDHANDLES

dwCreationFlags = CREATE_SUSPENDED | CREATE_NO_WINDOW # | CREATE_NEW_CONSOLE

if not CreateProcess(None,

u"cmd.exe /c " + cmd,

None, None, True, dwCreationFlags,

None, None, ctypes.byref(siStartInfo),

ctypes.byref(piProcInfo)):

raise ctypes.WinError()

# Close this process's versions of the child handles

CloseHandle(c_hstdin)

c_hstdin = None

CloseHandle(c_hstdout)

c_hstdout = None

if c_hstderr != None:

CloseHandle(c_hstderr)

c_hstderr = None

# Transfer ownership of the parent handles to the object

self.hstdin = p_hstdin

p_hstdin = None

self.hstdout = p_hstdout

p_hstdout = None

if not mergeout:

self.hstderr = p_hstderr

p_hstderr = None

self.piProcInfo = piProcInfo

finally:

if p_hstdin:

CloseHandle(p_hstdin)

if c_hstdin:

CloseHandle(c_hstdin)

if p_hstdout:

CloseHandle(p_hstdout)

if c_hstdout:

CloseHandle(c_hstdout)

if p_hstderr:

CloseHandle(p_hstderr)

if c_hstderr:

CloseHandle(c_hstderr)

return self

def _stdin_thread(self, handle, hprocess, func, stdout_func):

exitCode = DWORD()

bytesWritten = DWORD(0)

while True:

#print("stdin thread loop start")

# Get the input string (may be bytes or unicode)

data = func()

# None signals to poll whether the process has exited

if data is None:

#print("checking for process completion")

if not GetExitCodeProcess(hprocess, ctypes.byref(exitCode)):

raise ctypes.WinError()

if exitCode.value != STILL_ACTIVE:

return

# TESTING: Does zero-sized writefile help?

if not WriteFile(handle, "", 0,

ctypes.byref(bytesWritten), None):

raise ctypes.WinError()

continue

#print("\nGot str %s\n" % repr(data), file=sys.stderr)

# Encode the string to the console encoding

if isinstance(data, unicode): #FIXME: Python3

data = data.encode('utf_8')

# What we have now must be a string of bytes

if not isinstance(data, str): #FIXME: Python3

raise RuntimeError("internal stdin function string error")

# An empty string signals EOF

if len(data) == 0:

return

# In a windows console, sometimes the input is echoed,

# but sometimes not. How do we determine when to do this?

stdout_func(data)

# WriteFile may not accept all the data at once.

# Loop until everything is processed

while len(data) != 0:

#print("Calling writefile")

if not WriteFile(handle, data, len(data),

ctypes.byref(bytesWritten), None):

# This occurs at exit

if GetLastError() == ERROR_NO_DATA:

return

raise ctypes.WinError()

#print("Called writefile")

data = data[bytesWritten.value:]

def _stdout_thread(self, handle, func):

# Allocate the output buffer

data = ctypes.create_string_buffer(4096)

while True:

bytesRead = DWORD(0)

if not ReadFile(handle, data, 4096,

ctypes.byref(bytesRead), None):

le = GetLastError()

if le == ERROR_BROKEN_PIPE:

return

else:

raise ctypes.WinError()

# FIXME: Python3

s = data.value[0:bytesRead.value]

#print("\nv: %s" % repr(s), file=sys.stderr)

func(s.decode('utf_8', 'replace'))

def run(self, stdout_func = None, stdin_func = None, stderr_func = None):

"""Runs the process, using the provided functions for I/O.

if stdout_func == None and stdin_func == None and stderr_func == None:

return self._run_stdio()

if stderr_func != None and self.mergeout:

raise RuntimeError("Shell command was initiated with "

"merged stdin/stdout, but a separate stderr_func "

"was provided to the run() method")

# Create a thread for each input/output handle

stdin_thread = None

threads = []

if stdin_func:

stdin_thread = threading.Thread(target=self._stdin_thread,

args=(self.hstdin, self.piProcInfo.hProcess,

stdin_func, stdout_func))

threads.append(threading.Thread(target=self._stdout_thread,

args=(self.hstdout, stdout_func)))

if not self.mergeout:

if stderr_func == None:

stderr_func = stdout_func

threads.append(threading.Thread(target=self._stdout_thread,

args=(self.hstderr, stderr_func)))

# Start the I/O threads and the process

if ResumeThread(self.piProcInfo.hThread) == 0xFFFFFFFF:

raise ctypes.WinError()

if stdin_thread is not None:

stdin_thread.start()

for thread in threads:

thread.start()

# Wait for the process to complete

if WaitForSingleObject(self.piProcInfo.hProcess, INFINITE) == \

WAIT_FAILED:

raise ctypes.WinError()

# Wait for the I/O threads to complete

for thread in threads:

thread.join()

# Wait for the stdin thread to complete

if stdin_thread is not None:

stdin_thread.join()

def _stdin_raw_nonblock(self):

"""Use the raw Win32 handle of sys.stdin to do non-blocking reads"""

# WARNING: This is experimental, and produces inconsistent results.

# It's possible for the handle not to be appropriate for use

# with WaitForSingleObject, among other things.

handle = msvcrt.get_osfhandle(sys.stdin.fileno())

result = WaitForSingleObject(handle, 100)

if result == WAIT_FAILED:

raise ctypes.WinError()

elif result == WAIT_TIMEOUT:

print(".", end='')

return None

else:

data = ctypes.create_string_buffer(256)

bytesRead = DWORD(0)

print('?', end='')

if not ReadFile(handle, data, 256,

ctypes.byref(bytesRead), None):

raise ctypes.WinError()

# This ensures the non-blocking works with an actual console

# Not checking the error, so the processing will still work with

# other handle types

FlushConsoleInputBuffer(handle)

data = data.value

data = data.replace('\r\n', '\n')

data = data.replace('\r', '\n')

print(repr(data) + " ", end='')

return data

def _stdin_raw_block(self):

"""Use a blocking stdin read"""

# The big problem with the blocking read is that it doesn't

# exit when it's supposed to in all contexts. An extra

# key-press may be required to trigger the exit.

try:

data = sys.stdin.read(1)

data = data.replace('\r', '\n')

return data

except WindowsError as we:

if we.winerror == ERROR_NO_DATA:

# This error occurs when the pipe is closed

return None

else:

# Otherwise let the error propagate

raise we

def _stdout_raw(self, s):

"""Writes the string to stdout"""

print(s, end='', file=sys.stdout)

sys.stdout.flush()

def _stderr_raw(self, s):

"""Writes the string to stdout"""

print(s, end='', file=sys.stderr)

sys.stderr.flush()

def _run_stdio(self):

"""Runs the process using the system standard I/O.

# Disable Line and Echo mode

#lpMode = DWORD()

#handle = msvcrt.get_osfhandle(sys.stdin.fileno())

#if GetConsoleMode(handle, ctypes.byref(lpMode)):

# set_console_mode = True

# if not SetConsoleMode(handle, lpMode.value &

# ~(ENABLE_ECHO_INPUT | ENABLE_LINE_INPUT | ENABLE_PROCESSED_INPUT)):

# raise ctypes.WinError()

if self.mergeout:

return self.run(stdout_func = self._stdout_raw,

stdin_func = self._stdin_raw_block)

else:

return self.run(stdout_func = self._stdout_raw,

stdin_func = self._stdin_raw_block,

stderr_func = self._stderr_raw)

# Restore the previous console mode

#if set_console_mode:

# if not SetConsoleMode(handle, lpMode.value):

# raise ctypes.WinError()

def __exit__(self, exc_type, exc_value, traceback):

if self.hstdin:

CloseHandle(self.hstdin)

self.hstdin = None

if self.hstdout:

CloseHandle(self.hstdout)

self.hstdout = None

if self.hstderr:

CloseHandle(self.hstderr)

self.hstderr = None

if self.piProcInfo != None:

CloseHandle(self.piProcInfo.hProcess)

CloseHandle(self.piProcInfo.hThread)

"""Win32 version of os.system() that works with network shares.

with AvoidUNCPath() as path:

if path is not None:

cmd = '"pushd %s &&"%s' % (path, cmd)

with Win32ShellCommandController(cmd) as scc: