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
74
has_pywintypes = has_win32file = has_win32api = False
87
# pulling in win32com.shell is a bit of overhead, and normally we don't need
88
# it as ctypes is preferred and common. lazy_imports and "optional"
89
# modules don't work well, so we do our own lazy thing...
90
has_win32com_shell = None # Set to True or False once we know for sure...
92
# Special Win32 API constants
93
# Handles of std streams
94
WIN32_STDIN_HANDLE = -10
95
WIN32_STDOUT_HANDLE = -11
96
WIN32_STDERR_HANDLE = -12
98
# CSIDL constants (from MSDN 2003)
99
CSIDL_APPDATA = 0x001A # Application Data folder
100
CSIDL_LOCAL_APPDATA = 0x001c# <user name>\Local Settings\Application Data (non roaming)
101
CSIDL_PERSONAL = 0x0005 # My Documents folder
103
# from winapi C headers
106
MAX_COMPUTERNAME_LENGTH = 31
108
# Registry data type ids
113
def debug_memory_win32api(message='', short=True):
114
"""Use trace.note() to dump the running memory info."""
115
from bzrlib import trace
117
class PROCESS_MEMORY_COUNTERS_EX(ctypes.Structure):
118
"""Used by GetProcessMemoryInfo"""
119
_fields_ = [('cb', ctypes.c_ulong),
120
('PageFaultCount', ctypes.c_ulong),
121
('PeakWorkingSetSize', ctypes.c_size_t),
122
('WorkingSetSize', ctypes.c_size_t),
123
('QuotaPeakPagedPoolUsage', ctypes.c_size_t),
124
('QuotaPagedPoolUsage', ctypes.c_size_t),
125
('QuotaPeakNonPagedPoolUsage', ctypes.c_size_t),
126
('QuotaNonPagedPoolUsage', ctypes.c_size_t),
127
('PagefileUsage', ctypes.c_size_t),
128
('PeakPagefileUsage', ctypes.c_size_t),
129
('PrivateUsage', ctypes.c_size_t),
131
cur_process = ctypes.windll.kernel32.GetCurrentProcess()
132
mem_struct = PROCESS_MEMORY_COUNTERS_EX()
133
ret = ctypes.windll.psapi.GetProcessMemoryInfo(cur_process,
134
ctypes.byref(mem_struct),
135
ctypes.sizeof(mem_struct))
137
trace.note(gettext('Failed to GetProcessMemoryInfo()'))
139
info = {'PageFaultCount': mem_struct.PageFaultCount,
140
'PeakWorkingSetSize': mem_struct.PeakWorkingSetSize,
141
'WorkingSetSize': mem_struct.WorkingSetSize,
142
'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,
143
'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,
144
'QuotaPeakNonPagedPoolUsage':
145
mem_struct.QuotaPeakNonPagedPoolUsage,
146
'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,
147
'PagefileUsage': mem_struct.PagefileUsage,
148
'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
149
'PrivateUsage': mem_struct.PrivateUsage,
153
# win32process does not return PrivateUsage, because it doesn't use
154
# PROCESS_MEMORY_COUNTERS_EX (it uses the one without _EX).
155
proc = win32process.GetCurrentProcess()
156
info = win32process.GetProcessMemoryInfo(proc)
158
trace.note(gettext('Cannot debug memory on win32 without ctypes'
162
# using base-2 units (see HACKING.txt).
163
trace.note(gettext('WorkingSize {0:>7}KiB'
164
'\tPeakWorking {1:>7}KiB\t{2}').format(
165
info['WorkingSetSize'] / 1024,
166
info['PeakWorkingSetSize'] / 1024,
170
trace.note('%s', message)
171
trace.note(gettext('WorkingSize %8d KiB'), info['WorkingSetSize'] / 1024)
172
trace.note(gettext('PeakWorking %8d KiB'), info['PeakWorkingSetSize'] / 1024)
173
trace.note(gettext('PagefileUsage %8d KiB'), info.get('PagefileUsage', 0) / 1024)
174
trace.note(gettext('PeakPagefileUsage %8d KiB'),
175
info.get('PeakPagefileUsage', 0) / 1024)
176
trace.note(gettext('PrivateUsage %8d KiB'), info.get('PrivateUsage', 0) / 1024)
177
trace.note(gettext('PageFaultCount %8d'), info.get('PageFaultCount', 0))
180
def get_console_size(defaultx=80, defaulty=25):
181
"""Return size of current console.
183
This function try to determine actual size of current working
184
console window and return tuple (sizex, sizey) if success,
185
or default size (defaultx, defaulty) otherwise.
189
return (defaultx, defaulty)
191
# To avoid problem with redirecting output via pipe
192
# we need to use stderr instead of stdout
193
h = ctypes.windll.kernel32.GetStdHandle(WIN32_STDERR_HANDLE)
194
csbi = ctypes.create_string_buffer(22)
195
res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
198
(bufx, bufy, curx, cury, wattr,
199
left, top, right, bottom, maxx, maxy) = struct.unpack(
200
"hhhhHhhhhhh", csbi.raw)
201
sizex = right - left + 1
202
sizey = bottom - top + 1
203
return (sizex, sizey)
205
return (defaultx, defaulty)
208
def _get_sh_special_folder_path(csidl):
209
"""Call SHGetSpecialFolderPathW if available, or return None.
211
Result is always unicode (or None).
215
SHGetSpecialFolderPath = \
216
ctypes.windll.shell32.SHGetSpecialFolderPathW
217
except AttributeError:
220
buf = ctypes.create_unicode_buffer(MAX_PATH)
221
if SHGetSpecialFolderPath(None,buf,csidl,0):
224
global has_win32com_shell
225
if has_win32com_shell is None:
227
from win32com.shell import shell
228
has_win32com_shell = True
230
has_win32com_shell = False
231
if has_win32com_shell:
232
# still need to bind the name locally, but this is fast.
233
from win32com.shell import shell
235
return shell.SHGetSpecialFolderPath(0, csidl, 0)
237
# possibly E_NOTIMPL meaning we can't load the function pointer,
238
# or E_FAIL meaning the function failed - regardless, just ignore it
243
def get_appdata_location():
244
"""Return Application Data location.
245
Return None if we cannot obtain location.
247
Windows defines two 'Application Data' folders per user - a 'roaming'
248
one that moves with the user as they logon to different machines, and
249
a 'local' one that stays local to the machine. This returns the 'roaming'
250
directory, and thus is suitable for storing user-preferences, etc.
252
Returned value can be unicode or plain string.
253
To convert plain string to unicode use
254
s.decode(osutils.get_user_encoding())
255
(XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')
257
appdata = _get_sh_special_folder_path(CSIDL_APPDATA)
261
appdata = os.environ.get('APPDATA')
264
# if we fall to this point we on win98
265
# at least try C:/WINDOWS/Application Data
266
windir = os.environ.get('windir')
268
appdata = os.path.join(windir, 'Application Data')
269
if os.path.isdir(appdata):
271
# did not find anything
275
def get_local_appdata_location():
276
"""Return Local Application Data location.
277
Return the same as get_appdata_location() if we cannot obtain location.
279
Windows defines two 'Application Data' folders per user - a 'roaming'
280
one that moves with the user as they logon to different machines, and
281
a 'local' one that stays local to the machine. This returns the 'local'
282
directory, and thus is suitable for caches, temp files and other things
283
which don't need to move with the user.
285
Returned value can be unicode or plain string.
286
To convert plain string to unicode use
287
s.decode(osutils.get_user_encoding())
288
(XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')
290
local = _get_sh_special_folder_path(CSIDL_LOCAL_APPDATA)
293
# Vista supplies LOCALAPPDATA, but XP and earlier do not.
294
local = os.environ.get('LOCALAPPDATA')
297
return get_appdata_location()
300
def get_home_location():
301
"""Return user's home location.
302
Assume on win32 it's the <My Documents> folder.
303
If location cannot be obtained return system drive root,
306
Returned value can be unicode or plain string.
307
To convert plain string to unicode use
308
s.decode(osutils.get_user_encoding())
310
home = _get_sh_special_folder_path(CSIDL_PERSONAL)
313
# try for HOME env variable
314
home = os.path.expanduser('~')
317
# at least return windows root directory
318
windir = os.environ.get('windir')
320
return os.path.splitdrive(windir)[0] + '/'
321
# otherwise C:\ is good enough for 98% users
326
"""Return user name as login name.
327
If name cannot be obtained return None.
329
Returned value can be unicode or plain string.
330
To convert plain string to unicode use
331
s.decode(osutils.get_user_encoding())
335
advapi32 = ctypes.windll.advapi32
336
GetUserName = getattr(advapi32, 'GetUserName'+suffix)
337
except AttributeError:
340
buf = create_buffer(UNLEN+1)
341
n = ctypes.c_int(UNLEN+1)
342
if GetUserName(buf, ctypes.byref(n)):
344
# otherwise try env variables
345
return os.environ.get('USERNAME', None)
348
# 1 == ComputerNameDnsHostname, which returns "The DNS host name of the local
349
# computer or the cluster associated with the local computer."
350
_WIN32_ComputerNameDnsHostname = 1
353
"""Return host machine name.
354
If name cannot be obtained return None.
356
:return: A unicode string representing the host name. On win98, this may be
357
a plain string as win32 api doesn't support unicode.
361
return win32api.GetComputerNameEx(_WIN32_ComputerNameDnsHostname)
362
except (NotImplementedError, win32api.error):
363
# NotImplemented will happen on win9x...
367
kernel32 = ctypes.windll.kernel32
368
except AttributeError:
369
pass # Missing the module we need
371
buf = create_buffer(MAX_COMPUTERNAME_LENGTH+1)
372
n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
374
# Try GetComputerNameEx which gives a proper Unicode hostname
375
GetComputerNameEx = getattr(kernel32, 'GetComputerNameEx'+suffix,
377
if (GetComputerNameEx is not None
378
and GetComputerNameEx(_WIN32_ComputerNameDnsHostname,
379
buf, ctypes.byref(n))):
382
# Try GetComputerName in case GetComputerNameEx wasn't found
383
# It returns the NETBIOS name, which isn't as good, but still ok.
384
# The first GetComputerNameEx might have changed 'n', so reset it
385
n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
386
GetComputerName = getattr(kernel32, 'GetComputerName'+suffix,
388
if (GetComputerName is not None
389
and GetComputerName(buf, ctypes.byref(n))):
391
# otherwise try env variables, which will be 'mbcs' encoded
392
# on Windows (Python doesn't expose the native win32 unicode environment)
394
# http://msdn.microsoft.com/en-us/library/aa246807.aspx
395
# environment variables should always be encoded in 'mbcs'.
397
return os.environ['COMPUTERNAME'].decode("mbcs")
402
def _ensure_unicode(s):
403
if s and type(s) != unicode:
404
from bzrlib import osutils
405
s = s.decode(osutils.get_user_encoding())
409
def get_appdata_location_unicode():
410
return _ensure_unicode(get_appdata_location())
412
def get_home_location_unicode():
413
return _ensure_unicode(get_home_location())
415
def get_user_name_unicode():
416
return _ensure_unicode(get_user_name())
418
def get_host_name_unicode():
419
return _ensure_unicode(get_host_name())
422
def _ensure_with_dir(path):
423
if (not os.path.split(path)[0] or path.startswith(u'*')
424
or path.startswith(u'?')):
425
return u'./' + path, True
429
def _undo_ensure_with_dir(path, corrected):
437
def glob_one(possible_glob):
438
"""Same as glob.glob().
440
work around bugs in glob.glob()
441
- Python bug #1001604 ("glob doesn't return unicode with ...")
442
- failing expansion for */* with non-iso-8859-* chars
444
corrected_glob, corrected = _ensure_with_dir(possible_glob)
445
glob_files = glob.glob(corrected_glob)
448
# special case to let the normal code path handle
449
# files that do not exist, etc.
450
glob_files = [possible_glob]
452
glob_files = [_undo_ensure_with_dir(elem, corrected)
453
for elem in glob_files]
454
return [elem.replace(u'\\', u'/') for elem in glob_files]
457
def glob_expand(file_list):
458
"""Replacement for glob expansion by the shell.
460
Win32's cmd.exe does not do glob expansion (eg ``*.py``), so we do our own
463
:param file_list: A list of filenames which may include shell globs.
464
:return: An expanded list of filenames.
466
Introduced in bzrlib 0.18.
470
expanded_file_list = []
471
for possible_glob in file_list:
472
expanded_file_list.extend(glob_one(possible_glob))
473
return expanded_file_list
476
def get_app_path(appname):
477
r"""Look up in Windows registry for full path to application executable.
478
Typically, applications create subkey with their basename
479
in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\
481
:param appname: name of application (if no filename extension
482
is specified, .exe used)
483
:return: full path to aplication executable from registry,
484
or appname itself if nothing found.
489
if not os.path.splitext(basename)[1]:
490
basename = appname + '.exe'
493
hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
494
'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +
496
except EnvironmentError:
501
path, type_id = _winreg.QueryValueEx(hkey, '')
505
_winreg.CloseKey(hkey)
507
if type_id == REG_SZ:
509
if type_id == REG_EXPAND_SZ and has_win32api:
510
fullpath = win32api.ExpandEnvironmentStrings(path)
511
if len(fullpath) > 1 and fullpath[0] == '"' and fullpath[-1] == '"':
512
fullpath = fullpath[1:-1] # remove quotes around value
517
def set_file_attr_hidden(path):
518
"""Set file attributes to hidden if possible"""
520
if winver != 'Windows 98':
521
SetFileAttributes = win32file.SetFileAttributesW
523
SetFileAttributes = win32file.SetFileAttributes
525
SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)
526
except pywintypes.error, e:
527
from bzrlib import trace
528
trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
531
def _command_line_to_argv(command_line, argv, single_quotes_allowed=False):
532
"""Convert a Unicode command line into a list of argv arguments.
534
It performs wildcard expansion to make wildcards act closer to how they
535
work in posix shells, versus how they work by default on Windows. Quoted
536
arguments are left untouched.
538
:param command_line: The unicode string to split into an arg list.
539
:param single_quotes_allowed: Whether single quotes are accepted as quoting
540
characters like double quotes. False by
542
:return: A list of unicode strings.
544
# First, spit the command line
545
s = cmdline.Splitter(command_line, single_quotes_allowed=single_quotes_allowed)
547
# Bug #587868 Now make sure that the length of s agrees with sys.argv
548
# we do this by simply counting the number of arguments in each. The counts should
549
# agree no matter what encoding sys.argv is in (AFAIK)
550
# len(arguments) < len(sys.argv) should be an impossibility since python gets
551
# args from the very same PEB as does GetCommandLineW
554
# Now shorten the command line we get from GetCommandLineW to match sys.argv
555
if len(arguments) < len(argv):
556
raise AssertionError("Split command line can't be shorter than argv")
557
arguments = arguments[len(arguments) - len(argv):]
559
# Carry on to process globs (metachars) in the command line
560
# expand globs if necessary
561
# TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
564
for is_quoted, arg in arguments:
565
if is_quoted or not glob.has_magic(arg):
568
args.extend(glob_one(arg))
572
if has_ctypes and winver != 'Windows 98':
573
def get_unicode_argv():
574
prototype = ctypes.WINFUNCTYPE(ctypes.c_wchar_p)
575
GetCommandLineW = prototype(("GetCommandLineW",
576
ctypes.windll.kernel32))
577
command_line = GetCommandLineW()
578
if command_line is None:
579
raise ctypes.WinError()
580
# Skip the first argument, since we only care about parameters
581
argv = _command_line_to_argv(command_line, sys.argv)[1:]
584
get_unicode_argv = None
588
def _pywin32_is_local_pid_dead(pid):
589
"""True if pid doesn't correspond to live process on this machine"""
591
handle = win32api.OpenProcess(1, False, pid) # PROCESS_TERMINATE
592
except pywintypes.error, e:
593
if e[0] == 5: # ERROR_ACCESS_DENIED
594
# Probably something alive we're not allowed to kill
596
elif e[0] == 87: # ERROR_INVALID_PARAMETER
601
is_local_pid_dead = _pywin32_is_local_pid_dead
602
elif has_ctypes and sys.platform == 'win32':
603
from ctypes.wintypes import BOOL, DWORD, HANDLE
604
_kernel32 = ctypes.windll.kernel32
605
_CloseHandle = ctypes.WINFUNCTYPE(BOOL, HANDLE)(
606
("CloseHandle", _kernel32))
607
_OpenProcess = ctypes.WINFUNCTYPE(HANDLE, DWORD, BOOL, DWORD)(
608
("OpenProcess", _kernel32))
609
def _ctypes_is_local_pid_dead(pid):
610
"""True if pid doesn't correspond to live process on this machine"""
611
handle = _OpenProcess(1, False, pid) # PROCESS_TERMINATE
613
errorcode = ctypes.GetLastError()
614
if errorcode == 5: # ERROR_ACCESS_DENIED
615
# Probably something alive we're not allowed to kill
617
elif errorcode == 87: # ERROR_INVALID_PARAMETER
619
raise ctypes.WinError(errorcode)
622
is_local_pid_dead = _ctypes_is_local_pid_dead
625
def _is_pywintypes_error(evalue):
626
"""True if exception instance is an error from pywin32"""
627
if has_pywintypes and isinstance(evalue, pywintypes.error):
added
removed
bzrlib/win32utils.py
