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
33
from breezy.i18n import gettext
35
# We can cope without it; use a separate variable to help pyflakes
42
create_buffer = ctypes.create_unicode_buffer
43
extract_buffer = operator.attrgetter("value")
49
has_pywintypes = has_win32file = has_win32api = False
62
# pulling in win32com.shell is a bit of overhead, and normally we don't need
63
# it as ctypes is preferred and common. lazy_imports and "optional"
64
# modules don't work well, so we do our own lazy thing...
65
has_win32com_shell = None # Set to True or False once we know for sure...
67
# Special Win32 API constants
68
# Handles of std streams
69
WIN32_STDIN_HANDLE = -10
70
WIN32_STDOUT_HANDLE = -11
71
WIN32_STDERR_HANDLE = -12
73
# CSIDL constants (from MSDN 2003)
74
CSIDL_APPDATA = 0x001A # Application Data folder
75
# <user name>\Local Settings\Application Data (non roaming)
76
CSIDL_LOCAL_APPDATA = 0x001c
77
CSIDL_PERSONAL = 0x0005 # My Documents folder
79
# from winapi C headers
82
MAX_COMPUTERNAME_LENGTH = 31
84
# Registry data type ids
89
def debug_memory_win32api(message='', short=True):
90
"""Use trace.note() to dump the running memory info."""
91
from breezy import trace
93
class PROCESS_MEMORY_COUNTERS_EX(ctypes.Structure):
94
"""Used by GetProcessMemoryInfo"""
95
_fields_ = [('cb', ctypes.c_ulong),
96
('PageFaultCount', ctypes.c_ulong),
97
('PeakWorkingSetSize', ctypes.c_size_t),
98
('WorkingSetSize', ctypes.c_size_t),
99
('QuotaPeakPagedPoolUsage', ctypes.c_size_t),
100
('QuotaPagedPoolUsage', ctypes.c_size_t),
101
('QuotaPeakNonPagedPoolUsage', ctypes.c_size_t),
102
('QuotaNonPagedPoolUsage', ctypes.c_size_t),
103
('PagefileUsage', ctypes.c_size_t),
104
('PeakPagefileUsage', ctypes.c_size_t),
105
('PrivateUsage', ctypes.c_size_t),
107
cur_process = ctypes.windll.kernel32.GetCurrentProcess()
108
mem_struct = PROCESS_MEMORY_COUNTERS_EX()
109
ret = ctypes.windll.psapi.GetProcessMemoryInfo(
110
cur_process, ctypes.byref(mem_struct), ctypes.sizeof(mem_struct))
112
trace.note(gettext('Failed to GetProcessMemoryInfo()'))
114
info = {'PageFaultCount': mem_struct.PageFaultCount,
115
'PeakWorkingSetSize': mem_struct.PeakWorkingSetSize,
116
'WorkingSetSize': mem_struct.WorkingSetSize,
117
'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,
118
'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,
119
'QuotaPeakNonPagedPoolUsage':
120
mem_struct.QuotaPeakNonPagedPoolUsage,
121
'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,
122
'PagefileUsage': mem_struct.PagefileUsage,
123
'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
124
'PrivateUsage': mem_struct.PrivateUsage,
128
# win32process does not return PrivateUsage, because it doesn't use
129
# PROCESS_MEMORY_COUNTERS_EX (it uses the one without _EX).
130
proc = win32process.GetCurrentProcess()
131
info = win32process.GetProcessMemoryInfo(proc)
133
trace.note(gettext('Cannot debug memory on win32 without ctypes'
137
# using base-2 units (see HACKING.txt).
138
trace.note(gettext('WorkingSize {0:>7}KiB'
139
'\tPeakWorking {1:>7}KiB\t{2}').format(
140
info['WorkingSetSize'] / 1024,
141
info['PeakWorkingSetSize'] / 1024,
145
trace.note('%s', message)
146
trace.note(gettext('WorkingSize %8d KiB'),
147
info['WorkingSetSize'] / 1024)
148
trace.note(gettext('PeakWorking %8d KiB'),
149
info['PeakWorkingSetSize'] / 1024)
150
trace.note(gettext('PagefileUsage %8d KiB'),
151
info.get('PagefileUsage', 0) / 1024)
152
trace.note(gettext('PeakPagefileUsage %8d KiB'),
153
info.get('PeakPagefileUsage', 0) / 1024)
154
trace.note(gettext('PrivateUsage %8d KiB'),
155
info.get('PrivateUsage', 0) / 1024)
156
trace.note(gettext('PageFaultCount %8d'), info.get('PageFaultCount', 0))
159
def get_console_size(defaultx=80, defaulty=25):
160
"""Return size of current console.
162
This function try to determine actual size of current working
163
console window and return tuple (sizex, sizey) if success,
164
or default size (defaultx, defaulty) otherwise.
168
return (defaultx, defaulty)
170
# To avoid problem with redirecting output via pipe
171
# we need to use stderr instead of stdout
172
h = ctypes.windll.kernel32.GetStdHandle(WIN32_STDERR_HANDLE)
173
csbi = ctypes.create_string_buffer(22)
174
res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
177
(bufx, bufy, curx, cury, wattr,
178
left, top, right, bottom, maxx, maxy) = struct.unpack(
179
"hhhhHhhhhhh", csbi.raw)
180
sizex = right - left + 1
181
sizey = bottom - top + 1
182
return (sizex, sizey)
184
return (defaultx, defaulty)
187
def _get_sh_special_folder_path(csidl):
188
"""Call SHGetSpecialFolderPathW if available, or return None.
190
Result is always unicode (or None).
194
SHGetSpecialFolderPath = \
195
ctypes.windll.shell32.SHGetSpecialFolderPathW
196
except AttributeError:
199
buf = ctypes.create_unicode_buffer(MAX_PATH)
200
if SHGetSpecialFolderPath(None, buf, csidl, 0):
203
global has_win32com_shell
204
if has_win32com_shell is None:
206
from win32com.shell import shell
207
has_win32com_shell = True
209
has_win32com_shell = False
210
if has_win32com_shell:
211
# still need to bind the name locally, but this is fast.
212
from win32com.shell import shell
214
return shell.SHGetSpecialFolderPath(0, csidl, 0)
216
# possibly E_NOTIMPL meaning we can't load the function pointer,
217
# or E_FAIL meaning the function failed - regardless, just ignore it
222
def get_appdata_location():
223
"""Return Application Data location.
224
Return None if we cannot obtain location.
226
Windows defines two 'Application Data' folders per user - a 'roaming'
227
one that moves with the user as they logon to different machines, and
228
a 'local' one that stays local to the machine. This returns the 'roaming'
229
directory, and thus is suitable for storing user-preferences, etc.
231
appdata = _get_sh_special_folder_path(CSIDL_APPDATA)
234
# Use APPDATA if defined, will return None if not
235
return get_environ_unicode('APPDATA')
238
def get_local_appdata_location():
239
"""Return Local Application Data location.
240
Return the same as get_appdata_location() if we cannot obtain location.
242
Windows defines two 'Application Data' folders per user - a 'roaming'
243
one that moves with the user as they logon to different machines, and
244
a 'local' one that stays local to the machine. This returns the 'local'
245
directory, and thus is suitable for caches, temp files and other things
246
which don't need to move with the user.
248
local = _get_sh_special_folder_path(CSIDL_LOCAL_APPDATA)
251
# Vista supplies LOCALAPPDATA, but XP and earlier do not.
252
local = get_environ_unicode('LOCALAPPDATA')
255
return get_appdata_location()
258
def get_home_location():
259
"""Return user's home location.
260
Assume on win32 it's the <My Documents> folder.
261
If location cannot be obtained return system drive root,
264
home = _get_sh_special_folder_path(CSIDL_PERSONAL)
267
home = get_environ_unicode('HOME')
270
homepath = get_environ_unicode('HOMEPATH')
271
if homepath is not None:
272
return os.path.join(get_environ_unicode('HOMEDIR', ''), home)
273
# at least return windows root directory
274
windir = get_environ_unicode('WINDIR')
276
return os.path.splitdrive(windir)[0] + '/'
277
# otherwise C:\ is good enough for 98% users
282
"""Return user name as login name.
283
If name cannot be obtained return None.
287
advapi32 = ctypes.windll.advapi32
288
GetUserName = getattr(advapi32, 'GetUserName' + suffix)
289
except AttributeError:
292
buf = create_buffer(UNLEN + 1)
293
n = ctypes.c_int(UNLEN + 1)
294
if GetUserName(buf, ctypes.byref(n)):
295
return extract_buffer(buf)
296
# otherwise try env variables
297
return get_environ_unicode('USERNAME')
300
# 1 == ComputerNameDnsHostname, which returns "The DNS host name of the local
301
# computer or the cluster associated with the local computer."
302
_WIN32_ComputerNameDnsHostname = 1
306
"""Return host machine name.
307
If name cannot be obtained return None.
309
:return: A unicode string representing the host name.
313
return win32api.GetComputerNameEx(_WIN32_ComputerNameDnsHostname)
314
except (NotImplementedError, win32api.error):
315
# NotImplemented will happen on win9x...
319
kernel32 = ctypes.windll.kernel32
320
except AttributeError:
321
pass # Missing the module we need
323
buf = create_buffer(MAX_COMPUTERNAME_LENGTH + 1)
324
n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH + 1)
326
# Try GetComputerNameEx which gives a proper Unicode hostname
327
GetComputerNameEx = getattr(kernel32, 'GetComputerNameEx' + suffix,
329
if (GetComputerNameEx is not None
330
and GetComputerNameEx(_WIN32_ComputerNameDnsHostname,
331
buf, ctypes.byref(n))):
332
return extract_buffer(buf)
334
# Try GetComputerName in case GetComputerNameEx wasn't found
335
# It returns the NETBIOS name, which isn't as good, but still ok.
336
# The first GetComputerNameEx might have changed 'n', so reset it
337
n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH + 1)
338
GetComputerName = getattr(kernel32, 'GetComputerName' + suffix,
340
if (GetComputerName is not None
341
and GetComputerName(buf, ctypes.byref(n))):
342
return extract_buffer(buf)
343
return get_environ_unicode('COMPUTERNAME')
346
def _ensure_with_dir(path):
347
if (not os.path.split(path)[0] or path.startswith(u'*')
348
or path.startswith(u'?')):
349
return u'./' + path, True
354
def _undo_ensure_with_dir(path, corrected):
361
def glob_one(possible_glob):
362
"""Same as glob.glob().
364
work around bugs in glob.glob()
365
- Python bug #1001604 ("glob doesn't return unicode with ...")
366
- failing expansion for */* with non-iso-8859-* chars
368
corrected_glob, corrected = _ensure_with_dir(possible_glob)
369
glob_files = glob.glob(corrected_glob)
372
# special case to let the normal code path handle
373
# files that do not exist, etc.
374
glob_files = [possible_glob]
376
glob_files = [_undo_ensure_with_dir(elem, corrected)
377
for elem in glob_files]
378
return [elem.replace(u'\\', u'/') for elem in glob_files]
381
def glob_expand(file_list):
382
"""Replacement for glob expansion by the shell.
384
Win32's cmd.exe does not do glob expansion (eg ``*.py``), so we do our own
387
:param file_list: A list of filenames which may include shell globs.
388
:return: An expanded list of filenames.
390
Introduced in breezy 0.18.
394
expanded_file_list = []
395
for possible_glob in file_list:
396
expanded_file_list.extend(glob_one(possible_glob))
397
return expanded_file_list
400
def get_app_path(appname):
401
r"""Look up in Windows registry for full path to application executable.
402
Typically, applications create subkey with their basename
403
in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\
405
:param appname: name of application (if no filename extension
406
is specified, .exe used)
407
:return: full path to aplication executable from registry,
408
or appname itself if nothing found.
413
if not os.path.splitext(basename)[1]:
414
basename = appname + '.exe'
417
hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
418
'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +
420
except EnvironmentError:
425
path, type_id = _winreg.QueryValueEx(hkey, '')
429
_winreg.CloseKey(hkey)
431
if type_id == REG_SZ:
433
if type_id == REG_EXPAND_SZ and has_win32api:
434
fullpath = win32api.ExpandEnvironmentStrings(path)
435
if len(fullpath) > 1 and fullpath[0] == '"' and fullpath[-1] == '"':
436
fullpath = fullpath[1:-1] # remove quotes around value
441
def set_file_attr_hidden(path):
442
"""Set file attributes to hidden if possible"""
444
SetFileAttributes = win32file.SetFileAttributesW
446
SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)
447
except pywintypes.error as e:
449
trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
452
def _command_line_to_argv(command_line, argv, single_quotes_allowed=False):
453
"""Convert a Unicode command line into a list of argv arguments.
455
It performs wildcard expansion to make wildcards act closer to how they
456
work in posix shells, versus how they work by default on Windows. Quoted
457
arguments are left untouched.
459
:param command_line: The unicode string to split into an arg list.
460
:param single_quotes_allowed: Whether single quotes are accepted as quoting
461
characters like double quotes. False by
463
:return: A list of unicode strings.
465
# First, split the command line
466
s = cmdline.Splitter(
467
command_line, single_quotes_allowed=single_quotes_allowed)
469
# Bug #587868 Now make sure that the length of s agrees with sys.argv
470
# we do this by simply counting the number of arguments in each. The counts should
471
# agree no matter what encoding sys.argv is in (AFAIK)
472
# len(arguments) < len(sys.argv) should be an impossibility since python gets
473
# args from the very same PEB as does GetCommandLineW
476
# Now shorten the command line we get from GetCommandLineW to match sys.argv
477
if len(arguments) < len(argv):
478
raise AssertionError("Split command line can't be shorter than argv")
479
arguments = arguments[len(arguments) - len(argv):]
481
# Carry on to process globs (metachars) in the command line
482
# expand globs if necessary
483
# TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
486
for is_quoted, arg in arguments:
487
if is_quoted or not glob.has_magic(arg):
490
args.extend(glob_one(arg))
495
def get_unicode_argv():
496
prototype = ctypes.WINFUNCTYPE(ctypes.c_wchar_p)
497
GetCommandLineW = prototype(("GetCommandLineW",
498
ctypes.windll.kernel32))
499
command_line = GetCommandLineW()
500
if command_line is None:
501
raise ctypes.WinError()
502
# Skip the first argument, since we only care about parameters
503
argv = _command_line_to_argv(command_line, sys.argv)[1:]
506
def get_environ_unicode(key, default=None):
507
"""Get `key` from environment as unicode or `default` if unset
509
The environment is natively unicode on modern windows versions but
510
Python 2 only accesses it through the legacy bytestring api.
512
Environmental variable names are case insenstive on Windows.
514
A large enough buffer will be allocated to retrieve the value, though
515
it may take two calls to the underlying library function.
517
This needs ctypes because pywin32 does not expose the wide version.
519
cfunc = getattr(get_environ_unicode, "_c_function", None)
521
from ctypes.wintypes import DWORD, LPCWSTR, LPWSTR
522
cfunc = ctypes.WINFUNCTYPE(DWORD, LPCWSTR, LPWSTR, DWORD)(
523
("GetEnvironmentVariableW", ctypes.windll.kernel32))
524
get_environ_unicode._c_function = cfunc
525
buffer_size = 256 # heuristic, 256 characters often enough
527
buffer = ctypes.create_unicode_buffer(buffer_size)
528
length = cfunc(key, buffer, buffer_size)
530
code = ctypes.GetLastError()
531
if code == 203: # ERROR_ENVVAR_NOT_FOUND
533
raise ctypes.WinError(code)
534
if buffer_size > length:
535
return buffer[:length]
540
def _pywin32_is_local_pid_dead(pid):
541
"""True if pid doesn't correspond to live process on this machine"""
543
handle = win32api.OpenProcess(1, False, pid) # PROCESS_TERMINATE
544
except pywintypes.error as e:
545
if e[0] == 5: # ERROR_ACCESS_DENIED
546
# Probably something alive we're not allowed to kill
548
elif e[0] == 87: # ERROR_INVALID_PARAMETER
553
is_local_pid_dead = _pywin32_is_local_pid_dead
554
elif has_ctypes and sys.platform == 'win32':
555
from ctypes.wintypes import BOOL, DWORD, HANDLE
556
_kernel32 = ctypes.windll.kernel32
557
_CloseHandle = ctypes.WINFUNCTYPE(BOOL, HANDLE)(
558
("CloseHandle", _kernel32))
559
_OpenProcess = ctypes.WINFUNCTYPE(HANDLE, DWORD, BOOL, DWORD)(
560
("OpenProcess", _kernel32))
562
def _ctypes_is_local_pid_dead(pid):
563
"""True if pid doesn't correspond to live process on this machine"""
564
handle = _OpenProcess(1, False, pid) # PROCESS_TERMINATE
566
errorcode = ctypes.GetLastError()
567
if errorcode == 5: # ERROR_ACCESS_DENIED
568
# Probably something alive we're not allowed to kill
570
elif errorcode == 87: # ERROR_INVALID_PARAMETER
572
raise ctypes.WinError(errorcode)
575
is_local_pid_dead = _ctypes_is_local_pid_dead
578
def _is_pywintypes_error(evalue):
579
"""True if exception instance is an error from pywin32"""
580
if has_pywintypes and isinstance(evalue, pywintypes.error):
added
removed
breezy/win32utils.py
