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.
27
from bzrlib import cmdline
28
from bzrlib.i18n import gettext
31
if sys.platform == 'win32':
32
_major,_minor,_build,_platform,_text = sys.getwindowsversion()
35
# The operating system platform.
36
# This member can be one of the following values.
37
# ========================== ======================================
39
# -------------------------- --------------------------------------
40
# VER_PLATFORM_WIN32_NT The operating system is Windows Vista,
41
# 2 Windows Server "Longhorn",
42
# Windows Server 2003, Windows XP,
43
# Windows 2000, or Windows NT.
45
# VER_PLATFORM_WIN32_WINDOWS The operating system is Windows Me,
46
# 1 Windows 98, or Windows 95.
47
# ========================== ======================================
51
# don't care about real Windows name, just to force safe operations
57
# We can cope without it; use a separate variable to help pyflakes
64
if winver == 'Windows 98':
65
create_buffer = ctypes.create_string_buffer
68
create_buffer = ctypes.create_unicode_buffer
82
# pulling in win32com.shell is a bit of overhead, and normally we don't need
83
# it as ctypes is preferred and common. lazy_imports and "optional"
84
# modules don't work well, so we do our own lazy thing...
85
has_win32com_shell = None # Set to True or False once we know for sure...
87
# Special Win32 API constants
88
# Handles of std streams
89
WIN32_STDIN_HANDLE = -10
90
WIN32_STDOUT_HANDLE = -11
91
WIN32_STDERR_HANDLE = -12
93
# CSIDL constants (from MSDN 2003)
94
CSIDL_APPDATA = 0x001A # Application Data folder
95
CSIDL_LOCAL_APPDATA = 0x001c# <user name>\Local Settings\Application Data (non roaming)
96
CSIDL_PERSONAL = 0x0005 # My Documents folder
98
# from winapi C headers
101
MAX_COMPUTERNAME_LENGTH = 31
103
# Registry data type ids
108
def debug_memory_win32api(message='', short=True):
109
"""Use trace.note() to dump the running memory info."""
110
from bzrlib import trace
112
class PROCESS_MEMORY_COUNTERS_EX(ctypes.Structure):
113
"""Used by GetProcessMemoryInfo"""
114
_fields_ = [('cb', ctypes.c_ulong),
115
('PageFaultCount', ctypes.c_ulong),
116
('PeakWorkingSetSize', ctypes.c_size_t),
117
('WorkingSetSize', ctypes.c_size_t),
118
('QuotaPeakPagedPoolUsage', ctypes.c_size_t),
119
('QuotaPagedPoolUsage', ctypes.c_size_t),
120
('QuotaPeakNonPagedPoolUsage', ctypes.c_size_t),
121
('QuotaNonPagedPoolUsage', ctypes.c_size_t),
122
('PagefileUsage', ctypes.c_size_t),
123
('PeakPagefileUsage', ctypes.c_size_t),
124
('PrivateUsage', ctypes.c_size_t),
126
cur_process = ctypes.windll.kernel32.GetCurrentProcess()
127
mem_struct = PROCESS_MEMORY_COUNTERS_EX()
128
ret = ctypes.windll.psapi.GetProcessMemoryInfo(cur_process,
129
ctypes.byref(mem_struct),
130
ctypes.sizeof(mem_struct))
132
trace.note(gettext('Failed to GetProcessMemoryInfo()'))
134
info = {'PageFaultCount': mem_struct.PageFaultCount,
135
'PeakWorkingSetSize': mem_struct.PeakWorkingSetSize,
136
'WorkingSetSize': mem_struct.WorkingSetSize,
137
'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,
138
'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,
139
'QuotaPeakNonPagedPoolUsage':
140
mem_struct.QuotaPeakNonPagedPoolUsage,
141
'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,
142
'PagefileUsage': mem_struct.PagefileUsage,
143
'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
144
'PrivateUsage': mem_struct.PrivateUsage,
148
# win32process does not return PrivateUsage, because it doesn't use
149
# PROCESS_MEMORY_COUNTERS_EX (it uses the one without _EX).
150
proc = win32process.GetCurrentProcess()
151
info = win32process.GetProcessMemoryInfo(proc)
153
trace.note(gettext('Cannot debug memory on win32 without ctypes'
157
# using base-2 units (see HACKING.txt).
158
trace.note(gettext('WorkingSize {0:>7}KiB'
159
'\tPeakWorking {1:>7}KiB\t{2}').format(
160
info['WorkingSetSize'] / 1024,
161
info['PeakWorkingSetSize'] / 1024,
165
trace.note('%s', message)
166
trace.note(gettext('WorkingSize %8d KiB'), info['WorkingSetSize'] / 1024)
167
trace.note(gettext('PeakWorking %8d KiB'), info['PeakWorkingSetSize'] / 1024)
168
trace.note(gettext('PagefileUsage %8d KiB'), info.get('PagefileUsage', 0) / 1024)
169
trace.note(gettext('PeakPagefileUsage %8d KiB'),
170
info.get('PeakPagefileUsage', 0) / 1024)
171
trace.note(gettext('PrivateUsage %8d KiB'), info.get('PrivateUsage', 0) / 1024)
172
trace.note(gettext('PageFaultCount %8d'), info.get('PageFaultCount', 0))
175
def get_console_size(defaultx=80, defaulty=25):
176
"""Return size of current console.
178
This function try to determine actual size of current working
179
console window and return tuple (sizex, sizey) if success,
180
or default size (defaultx, defaulty) otherwise.
184
return (defaultx, defaulty)
186
# To avoid problem with redirecting output via pipe
187
# we need to use stderr instead of stdout
188
h = ctypes.windll.kernel32.GetStdHandle(WIN32_STDERR_HANDLE)
189
csbi = ctypes.create_string_buffer(22)
190
res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
193
(bufx, bufy, curx, cury, wattr,
194
left, top, right, bottom, maxx, maxy) = struct.unpack(
195
"hhhhHhhhhhh", csbi.raw)
196
sizex = right - left + 1
197
sizey = bottom - top + 1
198
return (sizex, sizey)
200
return (defaultx, defaulty)
203
def _get_sh_special_folder_path(csidl):
204
"""Call SHGetSpecialFolderPathW if available, or return None.
206
Result is always unicode (or None).
210
SHGetSpecialFolderPath = \
211
ctypes.windll.shell32.SHGetSpecialFolderPathW
212
except AttributeError:
215
buf = ctypes.create_unicode_buffer(MAX_PATH)
216
if SHGetSpecialFolderPath(None,buf,csidl,0):
219
global has_win32com_shell
220
if has_win32com_shell is None:
222
from win32com.shell import shell
223
has_win32com_shell = True
225
has_win32com_shell = False
226
if has_win32com_shell:
227
# still need to bind the name locally, but this is fast.
228
from win32com.shell import shell
230
return shell.SHGetSpecialFolderPath(0, csidl, 0)
232
# possibly E_NOTIMPL meaning we can't load the function pointer,
233
# or E_FAIL meaning the function failed - regardless, just ignore it
238
def get_appdata_location():
239
"""Return Application Data location.
240
Return None 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 'roaming'
245
directory, and thus is suitable for storing user-preferences, etc.
247
Returned value can be unicode or plain string.
248
To convert plain string to unicode use
249
s.decode(osutils.get_user_encoding())
250
(XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')
252
appdata = _get_sh_special_folder_path(CSIDL_APPDATA)
256
appdata = os.environ.get('APPDATA')
259
# if we fall to this point we on win98
260
# at least try C:/WINDOWS/Application Data
261
windir = os.environ.get('windir')
263
appdata = os.path.join(windir, 'Application Data')
264
if os.path.isdir(appdata):
266
# did not find anything
270
def get_local_appdata_location():
271
"""Return Local Application Data location.
272
Return the same as get_appdata_location() if we cannot obtain location.
274
Windows defines two 'Application Data' folders per user - a 'roaming'
275
one that moves with the user as they logon to different machines, and
276
a 'local' one that stays local to the machine. This returns the 'local'
277
directory, and thus is suitable for caches, temp files and other things
278
which don't need to move with the user.
280
Returned value can be unicode or plain string.
281
To convert plain string to unicode use
282
s.decode(osutils.get_user_encoding())
283
(XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')
285
local = _get_sh_special_folder_path(CSIDL_LOCAL_APPDATA)
288
# Vista supplies LOCALAPPDATA, but XP and earlier do not.
289
local = os.environ.get('LOCALAPPDATA')
292
return get_appdata_location()
295
def get_home_location():
296
"""Return user's home location.
297
Assume on win32 it's the <My Documents> folder.
298
If location cannot be obtained return system drive root,
301
Returned value can be unicode or plain string.
302
To convert plain string to unicode use
303
s.decode(osutils.get_user_encoding())
305
home = _get_sh_special_folder_path(CSIDL_PERSONAL)
308
# try for HOME env variable
309
home = os.path.expanduser('~')
312
# at least return windows root directory
313
windir = os.environ.get('windir')
315
return os.path.splitdrive(windir)[0] + '/'
316
# otherwise C:\ is good enough for 98% users
321
"""Return user name as login name.
322
If name cannot be obtained return None.
324
Returned value can be unicode or plain string.
325
To convert plain string to unicode use
326
s.decode(osutils.get_user_encoding())
330
advapi32 = ctypes.windll.advapi32
331
GetUserName = getattr(advapi32, 'GetUserName'+suffix)
332
except AttributeError:
335
buf = create_buffer(UNLEN+1)
336
n = ctypes.c_int(UNLEN+1)
337
if GetUserName(buf, ctypes.byref(n)):
339
# otherwise try env variables
340
return os.environ.get('USERNAME', None)
343
# 1 == ComputerNameDnsHostname, which returns "The DNS host name of the local
344
# computer or the cluster associated with the local computer."
345
_WIN32_ComputerNameDnsHostname = 1
348
"""Return host machine name.
349
If name cannot be obtained return None.
351
:return: A unicode string representing the host name. On win98, this may be
352
a plain string as win32 api doesn't support unicode.
356
return win32api.GetComputerNameEx(_WIN32_ComputerNameDnsHostname)
357
except (NotImplementedError, win32api.error):
358
# NotImplemented will happen on win9x...
362
kernel32 = ctypes.windll.kernel32
363
except AttributeError:
364
pass # Missing the module we need
366
buf = create_buffer(MAX_COMPUTERNAME_LENGTH+1)
367
n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
369
# Try GetComputerNameEx which gives a proper Unicode hostname
370
GetComputerNameEx = getattr(kernel32, 'GetComputerNameEx'+suffix,
372
if (GetComputerNameEx is not None
373
and GetComputerNameEx(_WIN32_ComputerNameDnsHostname,
374
buf, ctypes.byref(n))):
377
# Try GetComputerName in case GetComputerNameEx wasn't found
378
# It returns the NETBIOS name, which isn't as good, but still ok.
379
# The first GetComputerNameEx might have changed 'n', so reset it
380
n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
381
GetComputerName = getattr(kernel32, 'GetComputerName'+suffix,
383
if (GetComputerName is not None
384
and GetComputerName(buf, ctypes.byref(n))):
386
# otherwise try env variables, which will be 'mbcs' encoded
387
# on Windows (Python doesn't expose the native win32 unicode environment)
389
# http://msdn.microsoft.com/en-us/library/aa246807.aspx
390
# environment variables should always be encoded in 'mbcs'.
392
return os.environ['COMPUTERNAME'].decode("mbcs")
397
def _ensure_unicode(s):
398
if s and type(s) != unicode:
399
from bzrlib import osutils
400
s = s.decode(osutils.get_user_encoding())
404
def get_appdata_location_unicode():
405
return _ensure_unicode(get_appdata_location())
407
def get_home_location_unicode():
408
return _ensure_unicode(get_home_location())
410
def get_user_name_unicode():
411
return _ensure_unicode(get_user_name())
413
def get_host_name_unicode():
414
return _ensure_unicode(get_host_name())
417
def _ensure_with_dir(path):
418
if (not os.path.split(path)[0] or path.startswith(u'*')
419
or path.startswith(u'?')):
420
return u'./' + path, True
424
def _undo_ensure_with_dir(path, corrected):
432
def glob_one(possible_glob):
433
"""Same as glob.glob().
435
work around bugs in glob.glob()
436
- Python bug #1001604 ("glob doesn't return unicode with ...")
437
- failing expansion for */* with non-iso-8859-* chars
439
corrected_glob, corrected = _ensure_with_dir(possible_glob)
440
glob_files = glob.glob(corrected_glob)
443
# special case to let the normal code path handle
444
# files that do not exist, etc.
445
glob_files = [possible_glob]
447
glob_files = [_undo_ensure_with_dir(elem, corrected)
448
for elem in glob_files]
449
return [elem.replace(u'\\', u'/') for elem in glob_files]
452
def glob_expand(file_list):
453
"""Replacement for glob expansion by the shell.
455
Win32's cmd.exe does not do glob expansion (eg ``*.py``), so we do our own
458
:param file_list: A list of filenames which may include shell globs.
459
:return: An expanded list of filenames.
461
Introduced in bzrlib 0.18.
465
expanded_file_list = []
466
for possible_glob in file_list:
467
expanded_file_list.extend(glob_one(possible_glob))
468
return expanded_file_list
471
def get_app_path(appname):
472
r"""Look up in Windows registry for full path to application executable.
473
Typically, applications create subkey with their basename
474
in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\
476
:param appname: name of application (if no filename extension
477
is specified, .exe used)
478
:return: full path to aplication executable from registry,
479
or appname itself if nothing found.
484
if not os.path.splitext(basename)[1]:
485
basename = appname + '.exe'
488
hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
489
'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +
491
except EnvironmentError:
496
path, type_id = _winreg.QueryValueEx(hkey, '')
500
_winreg.CloseKey(hkey)
502
if type_id == REG_SZ:
504
if type_id == REG_EXPAND_SZ and has_win32api:
505
fullpath = win32api.ExpandEnvironmentStrings(path)
506
if len(fullpath) > 1 and fullpath[0] == '"' and fullpath[-1] == '"':
507
fullpath = fullpath[1:-1] # remove quotes around value
512
def set_file_attr_hidden(path):
513
"""Set file attributes to hidden if possible"""
515
if winver != 'Windows 98':
516
SetFileAttributes = win32file.SetFileAttributesW
518
SetFileAttributes = win32file.SetFileAttributes
520
SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)
521
except pywintypes.error, e:
522
from bzrlib import trace
523
trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
526
def _command_line_to_argv(command_line, argv, single_quotes_allowed=False):
527
"""Convert a Unicode command line into a list of argv arguments.
529
It performs wildcard expansion to make wildcards act closer to how they
530
work in posix shells, versus how they work by default on Windows. Quoted
531
arguments are left untouched.
533
:param command_line: The unicode string to split into an arg list.
534
:param single_quotes_allowed: Whether single quotes are accepted as quoting
535
characters like double quotes. False by
537
:return: A list of unicode strings.
539
# First, spit the command line
540
s = cmdline.Splitter(command_line, single_quotes_allowed=single_quotes_allowed)
542
# Bug #587868 Now make sure that the length of s agrees with sys.argv
543
# we do this by simply counting the number of arguments in each. The counts should
544
# agree no matter what encoding sys.argv is in (AFAIK)
545
# len(arguments) < len(sys.argv) should be an impossibility since python gets
546
# args from the very same PEB as does GetCommandLineW
549
# Now shorten the command line we get from GetCommandLineW to match sys.argv
550
if len(arguments) < len(argv):
551
raise AssertionError("Split command line can't be shorter than argv")
552
arguments = arguments[len(arguments) - len(argv):]
554
# Carry on to process globs (metachars) in the command line
555
# expand globs if necessary
556
# TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
559
for is_quoted, arg in arguments:
560
if is_quoted or not glob.has_magic(arg):
563
args.extend(glob_one(arg))
567
if has_ctypes and winver != 'Windows 98':
568
def get_unicode_argv():
569
prototype = ctypes.WINFUNCTYPE(ctypes.c_wchar_p)
570
GetCommandLineW = prototype(("GetCommandLineW",
571
ctypes.windll.kernel32))
572
command_line = GetCommandLineW()
573
if command_line is None:
574
raise ctypes.WinError()
575
# Skip the first argument, since we only care about parameters
576
argv = _command_line_to_argv(command_line, sys.argv)[1:]
579
get_unicode_argv = None
583
def _pywin32_is_local_pid_dead(pid):
584
"""True if pid doesn't correspond to live process on this machine"""
586
handle = win32api.OpenProcess(1, False, pid) # PROCESS_TERMINATE
587
except pywintypes.error, e:
588
if e[0] == 5: # ERROR_ACCESS_DENIED
589
# Probably something alive we're not allowed to kill
591
elif e[0] == 87: # ERROR_INVALID_PARAMETER
596
is_local_pid_dead = _pywin32_is_local_pid_dead
597
elif has_ctypes and sys.platform == 'win32':
598
from ctypes.wintypes import BOOL, DWORD, HANDLE
599
_kernel32 = ctypes.windll.kernel32
600
_CloseHandle = ctypes.WINFUNCTYPE(BOOL, HANDLE)(
601
("CloseHandle", _kernel32))
602
_OpenProcess = ctypes.WINFUNCTYPE(HANDLE, DWORD, BOOL, DWORD)(
603
("OpenProcess", _kernel32))
604
def _ctypes_is_local_pid_dead(pid):
605
"""True if pid doesn't correspond to live process on this machine"""
606
handle = _OpenProcess(1, False, pid) # PROCESS_TERMINATE
608
errorcode = ctypes.GetLastError()
609
if errorcode == 5: # ERROR_ACCESS_DENIED
610
# Probably something alive we're not allowed to kill
612
elif errorcode == 87: # ERROR_INVALID_PARAMETER
614
raise ctypes.WinError(errorcode)
617
is_local_pid_dead = _ctypes_is_local_pid_dead
added
removed
bzrlib/win32utils.py
