3
Set of functions to work with console on Windows.
4
Author: Alexander Belchenko (e-mail: bialix AT ukr.net)
1
# Copyright (C) 2005-2010 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
"""Win32-specific helper functions
19
Only one dependency: ctypes should be installed.
22
from __future__ import absolute_import
34
from bzrlib.i18n import gettext
37
if sys.platform == 'win32':
38
_major,_minor,_build,_platform,_text = sys.getwindowsversion()
41
# The operating system platform.
42
# This member can be one of the following values.
43
# ========================== ======================================
45
# -------------------------- --------------------------------------
46
# VER_PLATFORM_WIN32_NT The operating system is Windows Vista,
47
# 2 Windows Server "Longhorn",
48
# Windows Server 2003, Windows XP,
49
# Windows 2000, or Windows NT.
51
# VER_PLATFORM_WIN32_WINDOWS The operating system is Windows Me,
52
# 1 Windows 98, or Windows 95.
53
# ========================== ======================================
57
# don't care about real Windows name, just to force safe operations
63
# We can cope without it; use a separate variable to help pyflakes
70
if winver == 'Windows 98':
71
create_buffer = ctypes.create_string_buffer
72
def extract_buffer(buf):
73
return buf.value.decode("mbcs")
76
create_buffer = ctypes.create_unicode_buffer
77
extract_buffer = operator.attrgetter("value")
83
has_pywintypes = has_win32file = has_win32api = False
96
# pulling in win32com.shell is a bit of overhead, and normally we don't need
97
# it as ctypes is preferred and common. lazy_imports and "optional"
98
# modules don't work well, so we do our own lazy thing...
99
has_win32com_shell = None # Set to True or False once we know for sure...
101
# Special Win32 API constants
102
# Handles of std streams
103
WIN32_STDIN_HANDLE = -10
104
WIN32_STDOUT_HANDLE = -11
105
WIN32_STDERR_HANDLE = -12
107
# CSIDL constants (from MSDN 2003)
108
CSIDL_APPDATA = 0x001A # Application Data folder
109
CSIDL_LOCAL_APPDATA = 0x001c# <user name>\Local Settings\Application Data (non roaming)
110
CSIDL_PERSONAL = 0x0005 # My Documents folder
112
# from winapi C headers
115
MAX_COMPUTERNAME_LENGTH = 31
117
# Registry data type ids
122
def debug_memory_win32api(message='', short=True):
123
"""Use trace.note() to dump the running memory info."""
124
from bzrlib import trace
126
class PROCESS_MEMORY_COUNTERS_EX(ctypes.Structure):
127
"""Used by GetProcessMemoryInfo"""
128
_fields_ = [('cb', ctypes.c_ulong),
129
('PageFaultCount', ctypes.c_ulong),
130
('PeakWorkingSetSize', ctypes.c_size_t),
131
('WorkingSetSize', ctypes.c_size_t),
132
('QuotaPeakPagedPoolUsage', ctypes.c_size_t),
133
('QuotaPagedPoolUsage', ctypes.c_size_t),
134
('QuotaPeakNonPagedPoolUsage', ctypes.c_size_t),
135
('QuotaNonPagedPoolUsage', ctypes.c_size_t),
136
('PagefileUsage', ctypes.c_size_t),
137
('PeakPagefileUsage', ctypes.c_size_t),
138
('PrivateUsage', ctypes.c_size_t),
140
cur_process = ctypes.windll.kernel32.GetCurrentProcess()
141
mem_struct = PROCESS_MEMORY_COUNTERS_EX()
142
ret = ctypes.windll.psapi.GetProcessMemoryInfo(cur_process,
143
ctypes.byref(mem_struct),
144
ctypes.sizeof(mem_struct))
146
trace.note(gettext('Failed to GetProcessMemoryInfo()'))
148
info = {'PageFaultCount': mem_struct.PageFaultCount,
149
'PeakWorkingSetSize': mem_struct.PeakWorkingSetSize,
150
'WorkingSetSize': mem_struct.WorkingSetSize,
151
'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,
152
'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,
153
'QuotaPeakNonPagedPoolUsage':
154
mem_struct.QuotaPeakNonPagedPoolUsage,
155
'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,
156
'PagefileUsage': mem_struct.PagefileUsage,
157
'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
158
'PrivateUsage': mem_struct.PrivateUsage,
162
# win32process does not return PrivateUsage, because it doesn't use
163
# PROCESS_MEMORY_COUNTERS_EX (it uses the one without _EX).
164
proc = win32process.GetCurrentProcess()
165
info = win32process.GetProcessMemoryInfo(proc)
167
trace.note(gettext('Cannot debug memory on win32 without ctypes'
171
# using base-2 units (see HACKING.txt).
172
trace.note(gettext('WorkingSize {0:>7}KiB'
173
'\tPeakWorking {1:>7}KiB\t{2}').format(
174
info['WorkingSetSize'] / 1024,
175
info['PeakWorkingSetSize'] / 1024,
179
trace.note('%s', message)
180
trace.note(gettext('WorkingSize %8d KiB'), info['WorkingSetSize'] / 1024)
181
trace.note(gettext('PeakWorking %8d KiB'), info['PeakWorkingSetSize'] / 1024)
182
trace.note(gettext('PagefileUsage %8d KiB'), info.get('PagefileUsage', 0) / 1024)
183
trace.note(gettext('PeakPagefileUsage %8d KiB'),
184
info.get('PeakPagefileUsage', 0) / 1024)
185
trace.note(gettext('PrivateUsage %8d KiB'), info.get('PrivateUsage', 0) / 1024)
186
trace.note(gettext('PageFaultCount %8d'), info.get('PageFaultCount', 0))
16
189
def get_console_size(defaultx=80, defaulty=25):
17
""" Return size of current console.
19
This function try to determine actual size of current working
20
console window and return tuple (sizex, sizey) if success,
21
or default size (defaultx, defaulty) otherwise.
23
Dependencies: ctypes should be installed.
27
return (defaultx, defaulty)
29
h = ctypes.windll.kernel32.GetStdHandle(-11)
30
csbi = ctypes.create_string_buffer(22)
31
res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
34
(bufx, bufy, curx, cury, wattr,
35
left, top, right, bottom, maxx, maxy) = struct.unpack("hhhhHhhhhhh", csbi.raw)
36
sizex = right - left + 1
37
sizey = bottom - top + 1
40
return (defaultx, defaulty)
190
"""Return size of current console.
192
This function try to determine actual size of current working
193
console window and return tuple (sizex, sizey) if success,
194
or default size (defaultx, defaulty) otherwise.
198
return (defaultx, defaulty)
200
# To avoid problem with redirecting output via pipe
201
# we need to use stderr instead of stdout
202
h = ctypes.windll.kernel32.GetStdHandle(WIN32_STDERR_HANDLE)
203
csbi = ctypes.create_string_buffer(22)
204
res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
207
(bufx, bufy, curx, cury, wattr,
208
left, top, right, bottom, maxx, maxy) = struct.unpack(
209
"hhhhHhhhhhh", csbi.raw)
210
sizex = right - left + 1
211
sizey = bottom - top + 1
212
return (sizex, sizey)
214
return (defaultx, defaulty)
217
def _get_sh_special_folder_path(csidl):
218
"""Call SHGetSpecialFolderPathW if available, or return None.
220
Result is always unicode (or None).
224
SHGetSpecialFolderPath = \
225
ctypes.windll.shell32.SHGetSpecialFolderPathW
226
except AttributeError:
229
buf = ctypes.create_unicode_buffer(MAX_PATH)
230
if SHGetSpecialFolderPath(None,buf,csidl,0):
233
global has_win32com_shell
234
if has_win32com_shell is None:
236
from win32com.shell import shell
237
has_win32com_shell = True
239
has_win32com_shell = False
240
if has_win32com_shell:
241
# still need to bind the name locally, but this is fast.
242
from win32com.shell import shell
244
return shell.SHGetSpecialFolderPath(0, csidl, 0)
246
# possibly E_NOTIMPL meaning we can't load the function pointer,
247
# or E_FAIL meaning the function failed - regardless, just ignore it
252
def get_appdata_location():
253
"""Return Application Data location.
254
Return None if we cannot obtain location.
256
Windows defines two 'Application Data' folders per user - a 'roaming'
257
one that moves with the user as they logon to different machines, and
258
a 'local' one that stays local to the machine. This returns the 'roaming'
259
directory, and thus is suitable for storing user-preferences, etc.
261
appdata = _get_sh_special_folder_path(CSIDL_APPDATA)
264
# Use APPDATA if defined, will return None if not
265
return get_environ_unicode('APPDATA')
268
def get_local_appdata_location():
269
"""Return Local Application Data location.
270
Return the same as get_appdata_location() if we cannot obtain location.
272
Windows defines two 'Application Data' folders per user - a 'roaming'
273
one that moves with the user as they logon to different machines, and
274
a 'local' one that stays local to the machine. This returns the 'local'
275
directory, and thus is suitable for caches, temp files and other things
276
which don't need to move with the user.
278
local = _get_sh_special_folder_path(CSIDL_LOCAL_APPDATA)
281
# Vista supplies LOCALAPPDATA, but XP and earlier do not.
282
local = get_environ_unicode('LOCALAPPDATA')
285
return get_appdata_location()
288
def get_home_location():
289
"""Return user's home location.
290
Assume on win32 it's the <My Documents> folder.
291
If location cannot be obtained return system drive root,
294
home = _get_sh_special_folder_path(CSIDL_PERSONAL)
297
home = get_environ_unicode('HOME')
300
homepath = get_environ_unicode('HOMEPATH')
301
if homepath is not None:
302
return os.path.join(get_environ_unicode('HOMEDIR', ''), home)
303
# at least return windows root directory
304
windir = get_environ_unicode('WINDIR')
306
return os.path.splitdrive(windir)[0] + '/'
307
# otherwise C:\ is good enough for 98% users
308
return unicode('C:/')
312
"""Return user name as login name.
313
If name cannot be obtained return None.
317
advapi32 = ctypes.windll.advapi32
318
GetUserName = getattr(advapi32, 'GetUserName'+suffix)
319
except AttributeError:
322
buf = create_buffer(UNLEN+1)
323
n = ctypes.c_int(UNLEN+1)
324
if GetUserName(buf, ctypes.byref(n)):
325
return extract_buffer(buf)
326
# otherwise try env variables
327
return get_environ_unicode('USERNAME')
330
# 1 == ComputerNameDnsHostname, which returns "The DNS host name of the local
331
# computer or the cluster associated with the local computer."
332
_WIN32_ComputerNameDnsHostname = 1
335
"""Return host machine name.
336
If name cannot be obtained return None.
338
:return: A unicode string representing the host name.
342
return win32api.GetComputerNameEx(_WIN32_ComputerNameDnsHostname)
343
except (NotImplementedError, win32api.error):
344
# NotImplemented will happen on win9x...
348
kernel32 = ctypes.windll.kernel32
349
except AttributeError:
350
pass # Missing the module we need
352
buf = create_buffer(MAX_COMPUTERNAME_LENGTH+1)
353
n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
355
# Try GetComputerNameEx which gives a proper Unicode hostname
356
GetComputerNameEx = getattr(kernel32, 'GetComputerNameEx'+suffix,
358
if (GetComputerNameEx is not None
359
and GetComputerNameEx(_WIN32_ComputerNameDnsHostname,
360
buf, ctypes.byref(n))):
361
return extract_buffer(buf)
363
# Try GetComputerName in case GetComputerNameEx wasn't found
364
# It returns the NETBIOS name, which isn't as good, but still ok.
365
# The first GetComputerNameEx might have changed 'n', so reset it
366
n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
367
GetComputerName = getattr(kernel32, 'GetComputerName'+suffix,
369
if (GetComputerName is not None
370
and GetComputerName(buf, ctypes.byref(n))):
371
return extract_buffer(buf)
372
return get_environ_unicode('COMPUTERNAME')
375
@symbol_versioning.deprecated_function(
376
symbol_versioning.deprecated_in((2, 5, 0)))
377
def _ensure_unicode(s):
378
if s and type(s) != unicode:
379
from bzrlib import osutils
380
s = s.decode(osutils.get_user_encoding())
384
get_appdata_location_unicode = symbol_versioning.deprecated_function(
385
symbol_versioning.deprecated_in((2, 5, 0)))(get_appdata_location)
387
get_home_location_unicode = symbol_versioning.deprecated_function(
388
symbol_versioning.deprecated_in((2, 5, 0)))(get_home_location)
390
get_user_name_unicode = symbol_versioning.deprecated_function(
391
symbol_versioning.deprecated_in((2, 5, 0)))(get_user_name)
393
get_host_name_unicode = symbol_versioning.deprecated_function(
394
symbol_versioning.deprecated_in((2, 5, 0)))(get_host_name)
397
def _ensure_with_dir(path):
398
if (not os.path.split(path)[0] or path.startswith(u'*')
399
or path.startswith(u'?')):
400
return u'./' + path, True
404
def _undo_ensure_with_dir(path, corrected):
411
def glob_one(possible_glob):
412
"""Same as glob.glob().
414
work around bugs in glob.glob()
415
- Python bug #1001604 ("glob doesn't return unicode with ...")
416
- failing expansion for */* with non-iso-8859-* chars
418
corrected_glob, corrected = _ensure_with_dir(possible_glob)
419
glob_files = glob.glob(corrected_glob)
422
# special case to let the normal code path handle
423
# files that do not exist, etc.
424
glob_files = [possible_glob]
426
glob_files = [_undo_ensure_with_dir(elem, corrected)
427
for elem in glob_files]
428
return [elem.replace(u'\\', u'/') for elem in glob_files]
431
def glob_expand(file_list):
432
"""Replacement for glob expansion by the shell.
434
Win32's cmd.exe does not do glob expansion (eg ``*.py``), so we do our own
437
:param file_list: A list of filenames which may include shell globs.
438
:return: An expanded list of filenames.
440
Introduced in bzrlib 0.18.
444
expanded_file_list = []
445
for possible_glob in file_list:
446
expanded_file_list.extend(glob_one(possible_glob))
447
return expanded_file_list
450
def get_app_path(appname):
451
r"""Look up in Windows registry for full path to application executable.
452
Typically, applications create subkey with their basename
453
in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\
455
:param appname: name of application (if no filename extension
456
is specified, .exe used)
457
:return: full path to aplication executable from registry,
458
or appname itself if nothing found.
463
if not os.path.splitext(basename)[1]:
464
basename = appname + '.exe'
467
hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
468
'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +
470
except EnvironmentError:
475
path, type_id = _winreg.QueryValueEx(hkey, '')
479
_winreg.CloseKey(hkey)
481
if type_id == REG_SZ:
483
if type_id == REG_EXPAND_SZ and has_win32api:
484
fullpath = win32api.ExpandEnvironmentStrings(path)
485
if len(fullpath) > 1 and fullpath[0] == '"' and fullpath[-1] == '"':
486
fullpath = fullpath[1:-1] # remove quotes around value
491
def set_file_attr_hidden(path):
492
"""Set file attributes to hidden if possible"""
494
if winver != 'Windows 98':
495
SetFileAttributes = win32file.SetFileAttributesW
497
SetFileAttributes = win32file.SetFileAttributes
499
SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)
500
except pywintypes.error, e:
501
from bzrlib import trace
502
trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
505
def _command_line_to_argv(command_line, argv, single_quotes_allowed=False):
506
"""Convert a Unicode command line into a list of argv arguments.
508
It performs wildcard expansion to make wildcards act closer to how they
509
work in posix shells, versus how they work by default on Windows. Quoted
510
arguments are left untouched.
512
:param command_line: The unicode string to split into an arg list.
513
:param single_quotes_allowed: Whether single quotes are accepted as quoting
514
characters like double quotes. False by
516
:return: A list of unicode strings.
518
# First, split the command line
519
s = cmdline.Splitter(command_line, single_quotes_allowed=single_quotes_allowed)
521
# Bug #587868 Now make sure that the length of s agrees with sys.argv
522
# we do this by simply counting the number of arguments in each. The counts should
523
# agree no matter what encoding sys.argv is in (AFAIK)
524
# len(arguments) < len(sys.argv) should be an impossibility since python gets
525
# args from the very same PEB as does GetCommandLineW
528
# Now shorten the command line we get from GetCommandLineW to match sys.argv
529
if len(arguments) < len(argv):
530
raise AssertionError("Split command line can't be shorter than argv")
531
arguments = arguments[len(arguments) - len(argv):]
533
# Carry on to process globs (metachars) in the command line
534
# expand globs if necessary
535
# TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
538
for is_quoted, arg in arguments:
539
if is_quoted or not glob.has_magic(arg):
542
args.extend(glob_one(arg))
546
if has_ctypes and winver == 'Windows NT':
547
def get_unicode_argv():
548
prototype = ctypes.WINFUNCTYPE(ctypes.c_wchar_p)
549
GetCommandLineW = prototype(("GetCommandLineW",
550
ctypes.windll.kernel32))
551
command_line = GetCommandLineW()
552
if command_line is None:
553
raise ctypes.WinError()
554
# Skip the first argument, since we only care about parameters
555
argv = _command_line_to_argv(command_line, sys.argv)[1:]
559
def get_environ_unicode(key, default=None):
560
"""Get `key` from environment as unicode or `default` if unset
562
The environment is natively unicode on modern windows versions but
563
Python 2 only accesses it through the legacy bytestring api.
565
Environmental variable names are case insenstive on Windows.
567
A large enough buffer will be allocated to retrieve the value, though
568
it may take two calls to the underlying library function.
570
This needs ctypes because pywin32 does not expose the wide version.
572
cfunc = getattr(get_environ_unicode, "_c_function", None)
574
from ctypes.wintypes import DWORD, LPCWSTR, LPWSTR
575
cfunc = ctypes.WINFUNCTYPE(DWORD, LPCWSTR, LPWSTR, DWORD)(
576
("GetEnvironmentVariableW", ctypes.windll.kernel32))
577
get_environ_unicode._c_function = cfunc
578
buffer_size = 256 # heuristic, 256 characters often enough
580
buffer = ctypes.create_unicode_buffer(buffer_size)
581
length = cfunc(key, buffer, buffer_size)
583
code = ctypes.GetLastError()
584
if code == 203: # ERROR_ENVVAR_NOT_FOUND
586
raise ctypes.WinError(code)
587
if buffer_size > length:
588
return buffer[:length]
591
get_unicode_argv = None
592
def get_environ_unicode(key, default=None):
593
"""Get `key` from environment as unicode or `default` if unset
595
Fallback version that should basically never be needed.
597
from bzrlib import osutils
599
return os.environ[key].decode(osutils.get_user_encoding())
605
def _pywin32_is_local_pid_dead(pid):
606
"""True if pid doesn't correspond to live process on this machine"""
608
handle = win32api.OpenProcess(1, False, pid) # PROCESS_TERMINATE
609
except pywintypes.error, e:
610
if e[0] == 5: # ERROR_ACCESS_DENIED
611
# Probably something alive we're not allowed to kill
613
elif e[0] == 87: # ERROR_INVALID_PARAMETER
618
is_local_pid_dead = _pywin32_is_local_pid_dead
619
elif has_ctypes and sys.platform == 'win32':
620
from ctypes.wintypes import BOOL, DWORD, HANDLE
621
_kernel32 = ctypes.windll.kernel32
622
_CloseHandle = ctypes.WINFUNCTYPE(BOOL, HANDLE)(
623
("CloseHandle", _kernel32))
624
_OpenProcess = ctypes.WINFUNCTYPE(HANDLE, DWORD, BOOL, DWORD)(
625
("OpenProcess", _kernel32))
626
def _ctypes_is_local_pid_dead(pid):
627
"""True if pid doesn't correspond to live process on this machine"""
628
handle = _OpenProcess(1, False, pid) # PROCESS_TERMINATE
630
errorcode = ctypes.GetLastError()
631
if errorcode == 5: # ERROR_ACCESS_DENIED
632
# Probably something alive we're not allowed to kill
634
elif errorcode == 87: # ERROR_INVALID_PARAMETER
636
raise ctypes.WinError(errorcode)
639
is_local_pid_dead = _ctypes_is_local_pid_dead
642
def _is_pywintypes_error(evalue):
643
"""True if exception instance is an error from pywin32"""
644
if has_pywintypes and isinstance(evalue, pywintypes.error):
added
removed
bzrlib/win32utils.py
