win32.py
636 lines
| 21.4 KiB
| text/x-python
|
PythonLexer
/ mercurial / win32.py
|
r8226 | # win32.py - utility functions that use win32 API | ||
# | ||||
# Copyright 2005-2009 Matt Mackall <mpm@selenic.com> and others | ||||
# | ||||
# This software may be used and distributed according to the terms of the | ||||
|
r10263 | # GNU General Public License version 2 or any later version. | ||
|
r8227 | |||
|
r25994 | from __future__ import absolute_import | ||
import ctypes | ||||
import errno | ||||
import msvcrt | ||||
import os | ||||
import random | ||||
import subprocess | ||||
|
r13375 | |||
|
r30667 | from . import ( | ||
encoding, | ||||
pycompat, | ||||
) | ||||
|
r30637 | |||
|
r13375 | _kernel32 = ctypes.windll.kernel32 | ||
|
r14345 | _advapi32 = ctypes.windll.advapi32 | ||
_user32 = ctypes.windll.user32 | ||||
|
r33492 | _crypt32 = ctypes.windll.crypt32 | ||
|
r13375 | |||
_BOOL = ctypes.c_long | ||||
_WORD = ctypes.c_ushort | ||||
_DWORD = ctypes.c_ulong | ||||
|
r14345 | _UINT = ctypes.c_uint | ||
_LONG = ctypes.c_long | ||||
|
r13375 | _LPCSTR = _LPSTR = ctypes.c_char_p | ||
_HANDLE = ctypes.c_void_p | ||||
_HWND = _HANDLE | ||||
|
r33492 | _PCCERT_CONTEXT = ctypes.c_void_p | ||
|
r13375 | |||
|
r14345 | _INVALID_HANDLE_VALUE = _HANDLE(-1).value | ||
|
r13375 | |||
# GetLastError | ||||
_ERROR_SUCCESS = 0 | ||||
|
r21193 | _ERROR_NO_MORE_FILES = 18 | ||
|
r13375 | _ERROR_INVALID_PARAMETER = 87 | ||
|
r24652 | _ERROR_BROKEN_PIPE = 109 | ||
|
r13375 | _ERROR_INSUFFICIENT_BUFFER = 122 | ||
# WPARAM is defined as UINT_PTR (unsigned type) | ||||
# LPARAM is defined as LONG_PTR (signed type) | ||||
if ctypes.sizeof(ctypes.c_long) == ctypes.sizeof(ctypes.c_void_p): | ||||
_WPARAM = ctypes.c_ulong | ||||
_LPARAM = ctypes.c_long | ||||
elif ctypes.sizeof(ctypes.c_longlong) == ctypes.sizeof(ctypes.c_void_p): | ||||
_WPARAM = ctypes.c_ulonglong | ||||
_LPARAM = ctypes.c_longlong | ||||
class _FILETIME(ctypes.Structure): | ||||
_fields_ = [('dwLowDateTime', _DWORD), | ||||
('dwHighDateTime', _DWORD)] | ||||
class _BY_HANDLE_FILE_INFORMATION(ctypes.Structure): | ||||
_fields_ = [('dwFileAttributes', _DWORD), | ||||
('ftCreationTime', _FILETIME), | ||||
('ftLastAccessTime', _FILETIME), | ||||
('ftLastWriteTime', _FILETIME), | ||||
('dwVolumeSerialNumber', _DWORD), | ||||
('nFileSizeHigh', _DWORD), | ||||
('nFileSizeLow', _DWORD), | ||||
('nNumberOfLinks', _DWORD), | ||||
('nFileIndexHigh', _DWORD), | ||||
('nFileIndexLow', _DWORD)] | ||||
|
r18959 | # CreateFile | ||
|
r13375 | _FILE_SHARE_READ = 0x00000001 | ||
_FILE_SHARE_WRITE = 0x00000002 | ||||
_FILE_SHARE_DELETE = 0x00000004 | ||||
_OPEN_EXISTING = 3 | ||||
|
r17006 | _FILE_FLAG_BACKUP_SEMANTICS = 0x02000000 | ||
|
r13776 | # SetFileAttributes | ||
_FILE_ATTRIBUTE_NORMAL = 0x80 | ||||
|
r13795 | _FILE_ATTRIBUTE_NOT_CONTENT_INDEXED = 0x2000 | ||
|
r13776 | |||
|
r13375 | # Process Security and Access Rights | ||
_PROCESS_QUERY_INFORMATION = 0x0400 | ||||
# GetExitCodeProcess | ||||
_STILL_ACTIVE = 259 | ||||
class _STARTUPINFO(ctypes.Structure): | ||||
_fields_ = [('cb', _DWORD), | ||||
('lpReserved', _LPSTR), | ||||
('lpDesktop', _LPSTR), | ||||
('lpTitle', _LPSTR), | ||||
('dwX', _DWORD), | ||||
('dwY', _DWORD), | ||||
('dwXSize', _DWORD), | ||||
('dwYSize', _DWORD), | ||||
('dwXCountChars', _DWORD), | ||||
('dwYCountChars', _DWORD), | ||||
('dwFillAttribute', _DWORD), | ||||
('dwFlags', _DWORD), | ||||
('wShowWindow', _WORD), | ||||
('cbReserved2', _WORD), | ||||
('lpReserved2', ctypes.c_char_p), | ||||
('hStdInput', _HANDLE), | ||||
('hStdOutput', _HANDLE), | ||||
('hStdError', _HANDLE)] | ||||
class _PROCESS_INFORMATION(ctypes.Structure): | ||||
_fields_ = [('hProcess', _HANDLE), | ||||
('hThread', _HANDLE), | ||||
('dwProcessId', _DWORD), | ||||
('dwThreadId', _DWORD)] | ||||
|
r17050 | _CREATE_NO_WINDOW = 0x08000000 | ||
|
r13375 | _SW_HIDE = 0 | ||
|
r7890 | |||
|
r13375 | class _COORD(ctypes.Structure): | ||
_fields_ = [('X', ctypes.c_short), | ||||
('Y', ctypes.c_short)] | ||||
class _SMALL_RECT(ctypes.Structure): | ||||
_fields_ = [('Left', ctypes.c_short), | ||||
('Top', ctypes.c_short), | ||||
('Right', ctypes.c_short), | ||||
('Bottom', ctypes.c_short)] | ||||
class _CONSOLE_SCREEN_BUFFER_INFO(ctypes.Structure): | ||||
_fields_ = [('dwSize', _COORD), | ||||
('dwCursorPosition', _COORD), | ||||
('wAttributes', _WORD), | ||||
('srWindow', _SMALL_RECT), | ||||
('dwMaximumWindowSize', _COORD)] | ||||
|
r7890 | |||
|
r32664 | _STD_OUTPUT_HANDLE = _DWORD(-11).value | ||
|
r14344 | _STD_ERROR_HANDLE = _DWORD(-12).value | ||
|
r13375 | |||
|
r33492 | # CERT_TRUST_STATUS dwErrorStatus | ||
CERT_TRUST_IS_PARTIAL_CHAIN = 0x10000 | ||||
# CertCreateCertificateContext encodings | ||||
X509_ASN_ENCODING = 0x00000001 | ||||
PKCS_7_ASN_ENCODING = 0x00010000 | ||||
# These structs are only complete enough to achieve what we need. | ||||
class CERT_CHAIN_CONTEXT(ctypes.Structure): | ||||
_fields_ = ( | ||||
("cbSize", _DWORD), | ||||
# CERT_TRUST_STATUS struct | ||||
("dwErrorStatus", _DWORD), | ||||
("dwInfoStatus", _DWORD), | ||||
("cChain", _DWORD), | ||||
("rgpChain", ctypes.c_void_p), | ||||
("cLowerQualityChainContext", _DWORD), | ||||
("rgpLowerQualityChainContext", ctypes.c_void_p), | ||||
("fHasRevocationFreshnessTime", _BOOL), | ||||
("dwRevocationFreshnessTime", _DWORD), | ||||
) | ||||
class CERT_USAGE_MATCH(ctypes.Structure): | ||||
_fields_ = ( | ||||
("dwType", _DWORD), | ||||
# CERT_ENHKEY_USAGE struct | ||||
("cUsageIdentifier", _DWORD), | ||||
("rgpszUsageIdentifier", ctypes.c_void_p), # LPSTR * | ||||
) | ||||
class CERT_CHAIN_PARA(ctypes.Structure): | ||||
_fields_ = ( | ||||
("cbSize", _DWORD), | ||||
("RequestedUsage", CERT_USAGE_MATCH), | ||||
("RequestedIssuancePolicy", CERT_USAGE_MATCH), | ||||
("dwUrlRetrievalTimeout", _DWORD), | ||||
("fCheckRevocationFreshnessTime", _BOOL), | ||||
("dwRevocationFreshnessTime", _DWORD), | ||||
("pftCacheResync", ctypes.c_void_p), # LPFILETIME | ||||
("pStrongSignPara", ctypes.c_void_p), # PCCERT_STRONG_SIGN_PARA | ||||
("dwStrongSignFlags", _DWORD), | ||||
) | ||||
|
r14345 | # types of parameters of C functions used (required by pypy) | ||
|
r33492 | _crypt32.CertCreateCertificateContext.argtypes = [_DWORD, # cert encoding | ||
ctypes.c_char_p, # cert | ||||
_DWORD] # cert size | ||||
_crypt32.CertCreateCertificateContext.restype = _PCCERT_CONTEXT | ||||
_crypt32.CertGetCertificateChain.argtypes = [ | ||||
ctypes.c_void_p, # HCERTCHAINENGINE | ||||
_PCCERT_CONTEXT, | ||||
ctypes.c_void_p, # LPFILETIME | ||||
ctypes.c_void_p, # HCERTSTORE | ||||
ctypes.c_void_p, # PCERT_CHAIN_PARA | ||||
_DWORD, | ||||
ctypes.c_void_p, # LPVOID | ||||
ctypes.c_void_p # PCCERT_CHAIN_CONTEXT * | ||||
] | ||||
_crypt32.CertGetCertificateChain.restype = _BOOL | ||||
_crypt32.CertFreeCertificateContext.argtypes = [_PCCERT_CONTEXT] | ||||
_crypt32.CertFreeCertificateContext.restype = _BOOL | ||||
|
r14345 | _kernel32.CreateFileA.argtypes = [_LPCSTR, _DWORD, _DWORD, ctypes.c_void_p, | ||
_DWORD, _DWORD, _HANDLE] | ||||
_kernel32.CreateFileA.restype = _HANDLE | ||||
_kernel32.GetFileInformationByHandle.argtypes = [_HANDLE, ctypes.c_void_p] | ||||
_kernel32.GetFileInformationByHandle.restype = _BOOL | ||||
_kernel32.CloseHandle.argtypes = [_HANDLE] | ||||
_kernel32.CloseHandle.restype = _BOOL | ||||
|
r15095 | try: | ||
_kernel32.CreateHardLinkA.argtypes = [_LPCSTR, _LPCSTR, ctypes.c_void_p] | ||||
_kernel32.CreateHardLinkA.restype = _BOOL | ||||
except AttributeError: | ||||
pass | ||||
|
r14345 | |||
_kernel32.SetFileAttributesA.argtypes = [_LPCSTR, _DWORD] | ||||
_kernel32.SetFileAttributesA.restype = _BOOL | ||||
|
r35528 | _DRIVE_UNKNOWN = 0 | ||
_DRIVE_NO_ROOT_DIR = 1 | ||||
_DRIVE_REMOVABLE = 2 | ||||
_DRIVE_FIXED = 3 | ||||
_DRIVE_REMOTE = 4 | ||||
_DRIVE_CDROM = 5 | ||||
_DRIVE_RAMDISK = 6 | ||||
_kernel32.GetDriveTypeA.argtypes = [_LPCSTR] | ||||
_kernel32.GetDriveTypeA.restype = _UINT | ||||
_kernel32.GetVolumeInformationA.argtypes = [_LPCSTR, ctypes.c_void_p, _DWORD, | ||||
ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p, _DWORD] | ||||
_kernel32.GetVolumeInformationA.restype = _BOOL | ||||
_kernel32.GetVolumePathNameA.argtypes = [_LPCSTR, ctypes.c_void_p, _DWORD] | ||||
_kernel32.GetVolumePathNameA.restype = _BOOL | ||||
|
r14345 | _kernel32.OpenProcess.argtypes = [_DWORD, _BOOL, _DWORD] | ||
_kernel32.OpenProcess.restype = _HANDLE | ||||
_kernel32.GetExitCodeProcess.argtypes = [_HANDLE, ctypes.c_void_p] | ||||
_kernel32.GetExitCodeProcess.restype = _BOOL | ||||
_kernel32.GetLastError.argtypes = [] | ||||
_kernel32.GetLastError.restype = _DWORD | ||||
_kernel32.GetModuleFileNameA.argtypes = [_HANDLE, ctypes.c_void_p, _DWORD] | ||||
_kernel32.GetModuleFileNameA.restype = _DWORD | ||||
_kernel32.CreateProcessA.argtypes = [_LPCSTR, _LPCSTR, ctypes.c_void_p, | ||||
ctypes.c_void_p, _BOOL, _DWORD, ctypes.c_void_p, _LPCSTR, ctypes.c_void_p, | ||||
ctypes.c_void_p] | ||||
_kernel32.CreateProcessA.restype = _BOOL | ||||
_kernel32.ExitProcess.argtypes = [_UINT] | ||||
_kernel32.ExitProcess.restype = None | ||||
_kernel32.GetCurrentProcessId.argtypes = [] | ||||
_kernel32.GetCurrentProcessId.restype = _DWORD | ||||
_SIGNAL_HANDLER = ctypes.WINFUNCTYPE(_BOOL, _DWORD) | ||||
_kernel32.SetConsoleCtrlHandler.argtypes = [_SIGNAL_HANDLER, _BOOL] | ||||
_kernel32.SetConsoleCtrlHandler.restype = _BOOL | ||||
|
r32664 | _kernel32.SetConsoleMode.argtypes = [_HANDLE, _DWORD] | ||
_kernel32.SetConsoleMode.restype = _BOOL | ||||
_kernel32.GetConsoleMode.argtypes = [_HANDLE, ctypes.c_void_p] | ||||
_kernel32.GetConsoleMode.restype = _BOOL | ||||
|
r14345 | _kernel32.GetStdHandle.argtypes = [_DWORD] | ||
_kernel32.GetStdHandle.restype = _HANDLE | ||||
_kernel32.GetConsoleScreenBufferInfo.argtypes = [_HANDLE, ctypes.c_void_p] | ||||
_kernel32.GetConsoleScreenBufferInfo.restype = _BOOL | ||||
_advapi32.GetUserNameA.argtypes = [ctypes.c_void_p, ctypes.c_void_p] | ||||
_advapi32.GetUserNameA.restype = _BOOL | ||||
_user32.GetWindowThreadProcessId.argtypes = [_HANDLE, ctypes.c_void_p] | ||||
_user32.GetWindowThreadProcessId.restype = _DWORD | ||||
_user32.ShowWindow.argtypes = [_HANDLE, ctypes.c_int] | ||||
_user32.ShowWindow.restype = _BOOL | ||||
_WNDENUMPROC = ctypes.WINFUNCTYPE(_BOOL, _HWND, _LPARAM) | ||||
_user32.EnumWindows.argtypes = [_WNDENUMPROC, _LPARAM] | ||||
_user32.EnumWindows.restype = _BOOL | ||||
|
r24652 | _kernel32.PeekNamedPipe.argtypes = [_HANDLE, ctypes.c_void_p, _DWORD, | ||
ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p] | ||||
_kernel32.PeekNamedPipe.restype = _BOOL | ||||
|
r13375 | def _raiseoserror(name): | ||
|
r33419 | # Force the code to a signed int to avoid an 'int too large' error. | ||
# See https://bugs.python.org/issue28474 | ||||
code = _kernel32.GetLastError() | ||||
if code > 0x7fffffff: | ||||
code -= 2**32 | ||||
err = ctypes.WinError(code=code) | ||||
|
r34024 | raise OSError(err.errno, '%s: %s' % (name, | ||
encoding.strtolocal(err.strerror))) | ||||
|
r13375 | |||
def _getfileinfo(name): | ||||
fh = _kernel32.CreateFileA(name, 0, | ||||
_FILE_SHARE_READ | _FILE_SHARE_WRITE | _FILE_SHARE_DELETE, | ||||
|
r17006 | None, _OPEN_EXISTING, _FILE_FLAG_BACKUP_SEMANTICS, None) | ||
|
r13375 | if fh == _INVALID_HANDLE_VALUE: | ||
_raiseoserror(name) | ||||
try: | ||||
fi = _BY_HANDLE_FILE_INFORMATION() | ||||
if not _kernel32.GetFileInformationByHandle(fh, ctypes.byref(fi)): | ||||
_raiseoserror(name) | ||||
return fi | ||||
finally: | ||||
_kernel32.CloseHandle(fh) | ||||
|
r7890 | |||
|
r33492 | def checkcertificatechain(cert, build=True): | ||
'''Tests the given certificate to see if there is a complete chain to a | ||||
trusted root certificate. As a side effect, missing certificates are | ||||
downloaded and installed unless ``build=False``. True is returned if a | ||||
chain to a trusted root exists (even if built on the fly), otherwise | ||||
False. NB: A chain to a trusted root does NOT imply that the certificate | ||||
is valid. | ||||
''' | ||||
chainctxptr = ctypes.POINTER(CERT_CHAIN_CONTEXT) | ||||
pchainctx = chainctxptr() | ||||
chainpara = CERT_CHAIN_PARA(cbSize=ctypes.sizeof(CERT_CHAIN_PARA), | ||||
RequestedUsage=CERT_USAGE_MATCH()) | ||||
certctx = _crypt32.CertCreateCertificateContext(X509_ASN_ENCODING, cert, | ||||
len(cert)) | ||||
if certctx is None: | ||||
_raiseoserror('CertCreateCertificateContext') | ||||
flags = 0 | ||||
if not build: | ||||
flags |= 0x100 # CERT_CHAIN_DISABLE_AUTH_ROOT_AUTO_UPDATE | ||||
try: | ||||
# Building the certificate chain will update root certs as necessary. | ||||
if not _crypt32.CertGetCertificateChain(None, # hChainEngine | ||||
certctx, # pCertContext | ||||
None, # pTime | ||||
None, # hAdditionalStore | ||||
ctypes.byref(chainpara), | ||||
flags, | ||||
None, # pvReserved | ||||
ctypes.byref(pchainctx)): | ||||
_raiseoserror('CertGetCertificateChain') | ||||
chainctx = pchainctx.contents | ||||
return chainctx.dwErrorStatus & CERT_TRUST_IS_PARTIAL_CHAIN == 0 | ||||
finally: | ||||
if pchainctx: | ||||
_crypt32.CertFreeCertificateChain(pchainctx) | ||||
_crypt32.CertFreeCertificateContext(certctx) | ||||
|
r14235 | def oslink(src, dst): | ||
|
r13976 | try: | ||
if not _kernel32.CreateHardLinkA(dst, src, None): | ||||
_raiseoserror(src) | ||||
except AttributeError: # Wine doesn't support this function | ||||
|
r13375 | _raiseoserror(src) | ||
|
r7890 | |||
|
r13375 | def nlinks(name): | ||
'''return number of hardlinks for the given file''' | ||||
return _getfileinfo(name).nNumberOfLinks | ||||
|
r7890 | |||
|
r17006 | def samefile(path1, path2): | ||
'''Returns whether path1 and path2 refer to the same file or directory.''' | ||||
res1 = _getfileinfo(path1) | ||||
res2 = _getfileinfo(path2) | ||||
|
r13375 | return (res1.dwVolumeSerialNumber == res2.dwVolumeSerialNumber | ||
and res1.nFileIndexHigh == res2.nFileIndexHigh | ||||
and res1.nFileIndexLow == res2.nFileIndexLow) | ||||
|
r10218 | |||
|
r17006 | def samedevice(path1, path2): | ||
'''Returns whether path1 and path2 are on the same device.''' | ||||
res1 = _getfileinfo(path1) | ||||
res2 = _getfileinfo(path2) | ||||
|
r13375 | return res1.dwVolumeSerialNumber == res2.dwVolumeSerialNumber | ||
|
r10218 | |||
|
r24652 | def peekpipe(pipe): | ||
handle = msvcrt.get_osfhandle(pipe.fileno()) | ||||
avail = _DWORD() | ||||
if not _kernel32.PeekNamedPipe(handle, None, 0, None, ctypes.byref(avail), | ||||
None): | ||||
err = _kernel32.GetLastError() | ||||
if err == _ERROR_BROKEN_PIPE: | ||||
return 0 | ||||
raise ctypes.WinError(err) | ||||
return avail.value | ||||
|
r7890 | def testpid(pid): | ||
'''return True if pid is still running or unable to | ||||
determine, False otherwise''' | ||||
|
r13375 | h = _kernel32.OpenProcess(_PROCESS_QUERY_INFORMATION, False, pid) | ||
if h: | ||||
try: | ||||
status = _DWORD() | ||||
if _kernel32.GetExitCodeProcess(h, ctypes.byref(status)): | ||||
return status.value == _STILL_ACTIVE | ||||
finally: | ||||
_kernel32.CloseHandle(h) | ||||
return _kernel32.GetLastError() != _ERROR_INVALID_PARAMETER | ||||
|
r7890 | |||
|
r14236 | def executablepath(): | ||
|
r13376 | '''return full path of hg.exe''' | ||
|
r13375 | size = 600 | ||
buf = ctypes.create_string_buffer(size + 1) | ||||
len = _kernel32.GetModuleFileNameA(None, ctypes.byref(buf), size) | ||||
if len == 0: | ||||
|
r24494 | raise ctypes.WinError() # Note: WinError is a function | ||
|
r13375 | elif len == size: | ||
raise ctypes.WinError(_ERROR_INSUFFICIENT_BUFFER) | ||||
|
r13376 | return buf.value | ||
|
r35530 | def getvolumename(path): | ||
"""Get the mount point of the filesystem from a directory or file | ||||
(best-effort) | ||||
|
r35528 | |||
Returns None if we are unsure. Raises OSError on ENOENT, EPERM, etc. | ||||
""" | ||||
# realpath() calls GetFullPathName() | ||||
realpath = os.path.realpath(path) | ||||
size = len(realpath) + 1 | ||||
buf = ctypes.create_string_buffer(size) | ||||
if not _kernel32.GetVolumePathNameA(realpath, ctypes.byref(buf), size): | ||||
raise ctypes.WinError() # Note: WinError is a function | ||||
|
r35530 | return buf.value | ||
def getfstype(path): | ||||
"""Get the filesystem type name from a directory or file (best-effort) | ||||
Returns None if we are unsure. Raises OSError on ENOENT, EPERM, etc. | ||||
""" | ||||
volume = getvolumename(path) | ||||
t = _kernel32.GetDriveTypeA(volume) | ||||
|
r35528 | |||
if t == _DRIVE_REMOTE: | ||||
return 'cifs' | ||||
elif t not in (_DRIVE_REMOVABLE, _DRIVE_FIXED, _DRIVE_CDROM, | ||||
_DRIVE_RAMDISK): | ||||
return None | ||||
size = 256 | ||||
name = ctypes.create_string_buffer(size) | ||||
|
r35530 | if not _kernel32.GetVolumeInformationA(volume, None, 0, None, None, None, | ||
|
r35528 | ctypes.byref(name), size): | ||
raise ctypes.WinError() # Note: WinError is a function | ||||
return name.value | ||||
|
r7890 | def getuser(): | ||
'''return name of current user''' | ||||
|
r13375 | size = _DWORD(300) | ||
buf = ctypes.create_string_buffer(size.value + 1) | ||||
|
r14345 | if not _advapi32.GetUserNameA(ctypes.byref(buf), ctypes.byref(size)): | ||
|
r24418 | raise ctypes.WinError() | ||
|
r13375 | return buf.value | ||
|
r7890 | |||
|
r14237 | _signalhandler = [] | ||
|
r13375 | |||
|
r14237 | def setsignalhandler(): | ||
|
r13375 | '''Register a termination handler for console events including | ||
|
r7890 | CTRL+C. python signal handlers do not work well with socket | ||
operations. | ||||
|
r13375 | ''' | ||
|
r7890 | def handler(event): | ||
|
r13375 | _kernel32.ExitProcess(1) | ||
|
r14237 | if _signalhandler: | ||
|
r13375 | return # already registered | ||
h = _SIGNAL_HANDLER(handler) | ||||
|
r14237 | _signalhandler.append(h) # needed to prevent garbage collection | ||
|
r13375 | if not _kernel32.SetConsoleCtrlHandler(h, True): | ||
|
r24418 | raise ctypes.WinError() | ||
|
r13375 | |||
|
r10240 | def hidewindow(): | ||
|
r13375 | def callback(hwnd, pid): | ||
wpid = _DWORD() | ||||
|
r14345 | _user32.GetWindowThreadProcessId(hwnd, ctypes.byref(wpid)) | ||
|
r13375 | if pid == wpid.value: | ||
|
r14345 | _user32.ShowWindow(hwnd, _SW_HIDE) | ||
|
r13375 | return False # stop enumerating windows | ||
return True | ||||
pid = _kernel32.GetCurrentProcessId() | ||||
|
r14345 | _user32.EnumWindows(_WNDENUMPROC(callback), pid) | ||
|
r11012 | |||
|
r30314 | def termsize(): | ||
|
r13375 | # cmd.exe does not handle CR like a unix console, the CR is | ||
# counted in the line length. On 80 columns consoles, if 80 | ||||
# characters are written, the following CR won't apply on the | ||||
# current line but on the new one. Keep room for it. | ||||
|
r30313 | width = 80 - 1 | ||
|
r30314 | height = 25 | ||
|
r13375 | # Query stderr to avoid problems with redirections | ||
screenbuf = _kernel32.GetStdHandle( | ||||
_STD_ERROR_HANDLE) # don't close the handle returned | ||||
if screenbuf is None or screenbuf == _INVALID_HANDLE_VALUE: | ||||
|
r30314 | return width, height | ||
|
r13375 | csbi = _CONSOLE_SCREEN_BUFFER_INFO() | ||
if not _kernel32.GetConsoleScreenBufferInfo( | ||||
screenbuf, ctypes.byref(csbi)): | ||||
|
r30314 | return width, height | ||
|
r30313 | width = csbi.srWindow.Right - csbi.srWindow.Left # don't '+ 1' | ||
|
r30314 | height = csbi.srWindow.Bottom - csbi.srWindow.Top + 1 | ||
return width, height | ||||
|
r13375 | |||
|
r32664 | def enablevtmode(): | ||
'''Enable virtual terminal mode for the associated console. Return True if | ||||
enabled, else False.''' | ||||
ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x4 | ||||
handle = _kernel32.GetStdHandle(_STD_OUTPUT_HANDLE) # don't close the handle | ||||
if handle == _INVALID_HANDLE_VALUE: | ||||
return False | ||||
mode = _DWORD(0) | ||||
if not _kernel32.GetConsoleMode(handle, ctypes.byref(mode)): | ||||
return False | ||||
if (mode.value & ENABLE_VIRTUAL_TERMINAL_PROCESSING) == 0: | ||||
mode.value |= ENABLE_VIRTUAL_TERMINAL_PROCESSING | ||||
if not _kernel32.SetConsoleMode(handle, mode): | ||||
return False | ||||
return True | ||||
|
r13375 | def spawndetached(args): | ||
# No standard library function really spawns a fully detached | ||||
# process under win32 because they allocate pipes or other objects | ||||
# to handle standard streams communications. Passing these objects | ||||
# to the child process requires handle inheritance to be enabled | ||||
# which makes really detached processes impossible. | ||||
si = _STARTUPINFO() | ||||
si.cb = ctypes.sizeof(_STARTUPINFO) | ||||
pi = _PROCESS_INFORMATION() | ||||
env = '' | ||||
|
r30637 | for k in encoding.environ: | ||
env += "%s=%s\0" % (k, encoding.environ[k]) | ||||
|
r13375 | if not env: | ||
env = '\0' | ||||
env += '\0' | ||||
args = subprocess.list2cmdline(args) | ||||
res = _kernel32.CreateProcessA( | ||||
|
r17050 | None, args, None, None, False, _CREATE_NO_WINDOW, | ||
|
r30667 | env, pycompat.getcwd(), ctypes.byref(si), ctypes.byref(pi)) | ||
|
r13375 | if not res: | ||
|
r24418 | raise ctypes.WinError() | ||
|
r13375 | |||
|
r32676 | return pi.dwProcessId | ||
|
r13775 | |||
def unlink(f): | ||||
'''try to implement POSIX' unlink semantics on Windows''' | ||||
|
r21226 | if os.path.isdir(f): | ||
# use EPERM because it is POSIX prescribed value, even though | ||||
# unlink(2) on directories returns EISDIR on Linux | ||||
raise IOError(errno.EPERM, | ||||
"Unlinking directory not permitted: '%s'" % f) | ||||
|
r19159 | |||
|
r13775 | # POSIX allows to unlink and rename open files. Windows has serious | ||
# problems with doing that: | ||||
# - Calling os.unlink (or os.rename) on a file f fails if f or any | ||||
# hardlinked copy of f has been opened with Python's open(). There is no | ||||
# way such a file can be deleted or renamed on Windows (other than | ||||
# scheduling the delete or rename for the next reboot). | ||||
# - Calling os.unlink on a file that has been opened with Mercurial's | ||||
# posixfile (or comparable methods) will delay the actual deletion of | ||||
# the file for as long as the file is held open. The filename is blocked | ||||
# during that time and cannot be used for recreating a new file under | ||||
# that same name ("zombie file"). Directories containing such zombie files | ||||
# cannot be removed or moved. | ||||
# A file that has been opened with posixfile can be renamed, so we rename | ||||
# f to a random temporary name before calling os.unlink on it. This allows | ||||
# callers to recreate f immediately while having other readers do their | ||||
# implicit zombie filename blocking on a temporary name. | ||||
for tries in xrange(10): | ||||
temp = '%s-%08x' % (f, random.randint(0, 0xffffffff)) | ||||
try: | ||||
os.rename(f, temp) # raises OSError EEXIST if temp exists | ||||
break | ||||
|
r25660 | except OSError as e: | ||
|
r13775 | if e.errno != errno.EEXIST: | ||
raise | ||||
else: | ||||
|
r18175 | raise IOError(errno.EEXIST, "No usable temporary filename found") | ||
|
r13775 | |||
try: | ||||
os.unlink(temp) | ||||
|
r13776 | except OSError: | ||
# The unlink might have failed because the READONLY attribute may heave | ||||
# been set on the original file. Rename works fine with READONLY set, | ||||
# but not os.unlink. Reset all attributes and try again. | ||||
_kernel32.SetFileAttributesA(temp, _FILE_ATTRIBUTE_NORMAL) | ||||
try: | ||||
os.unlink(temp) | ||||
except OSError: | ||||
# The unlink might have failed due to some very rude AV-Scanners. | ||||
# Leaking a tempfile is the lesser evil than aborting here and | ||||
# leaving some potentially serious inconsistencies. | ||||
pass | ||||
|
r13795 | |||
def makedir(path, notindexed): | ||||
os.mkdir(path) | ||||
if notindexed: | ||||
_kernel32.SetFileAttributesA(path, _FILE_ATTRIBUTE_NOT_CONTENT_INDEXED) | ||||