81
82
MAX_COMPUTERNAME_LENGTH = 31
83
# Registry data type ids
88
def debug_memory_win32api(message='', short=True):
89
"""Use trace.note() to dump the running memory info."""
90
from breezy import trace
92
class PROCESS_MEMORY_COUNTERS_EX(ctypes.Structure):
93
"""Used by GetProcessMemoryInfo"""
94
_fields_ = [('cb', ctypes.c_ulong),
95
('PageFaultCount', ctypes.c_ulong),
96
('PeakWorkingSetSize', ctypes.c_size_t),
97
('WorkingSetSize', ctypes.c_size_t),
98
('QuotaPeakPagedPoolUsage', ctypes.c_size_t),
99
('QuotaPagedPoolUsage', ctypes.c_size_t),
100
('QuotaPeakNonPagedPoolUsage', ctypes.c_size_t),
101
('QuotaNonPagedPoolUsage', ctypes.c_size_t),
102
('PagefileUsage', ctypes.c_size_t),
103
('PeakPagefileUsage', ctypes.c_size_t),
104
('PrivateUsage', ctypes.c_size_t),
106
cur_process = ctypes.windll.kernel32.GetCurrentProcess()
107
mem_struct = PROCESS_MEMORY_COUNTERS_EX()
108
ret = ctypes.windll.psapi.GetProcessMemoryInfo(cur_process,
109
ctypes.byref(mem_struct),
110
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'), info['WorkingSetSize'] / 1024)
147
trace.note(gettext('PeakWorking %8d KiB'), info['PeakWorkingSetSize'] / 1024)
148
trace.note(gettext('PagefileUsage %8d KiB'), info.get('PagefileUsage', 0) / 1024)
149
trace.note(gettext('PeakPagefileUsage %8d KiB'),
150
info.get('PeakPagefileUsage', 0) / 1024)
151
trace.note(gettext('PrivateUsage %8d KiB'), info.get('PrivateUsage', 0) / 1024)
152
trace.note(gettext('PageFaultCount %8d'), info.get('PageFaultCount', 0))
155
85
def get_console_size(defaultx=80, defaulty=25):
156
86
"""Return size of current console.
180
109
return (defaultx, defaulty)
183
def _get_sh_special_folder_path(csidl):
184
"""Call SHGetSpecialFolderPathW if available, or return None.
186
Result is always unicode (or None).
190
SHGetSpecialFolderPath = \
191
ctypes.windll.shell32.SHGetSpecialFolderPathW
192
except AttributeError:
195
buf = ctypes.create_unicode_buffer(MAX_PATH)
196
if SHGetSpecialFolderPath(None, buf, csidl, 0):
199
global has_win32com_shell
200
if has_win32com_shell is None:
202
from win32com.shell import shell
203
has_win32com_shell = True
205
has_win32com_shell = False
206
if has_win32com_shell:
207
# still need to bind the name locally, but this is fast.
208
from win32com.shell import shell
210
return shell.SHGetSpecialFolderPath(0, csidl, 0)
212
# possibly E_NOTIMPL meaning we can't load the function pointer,
213
# or E_FAIL meaning the function failed - regardless, just ignore it
218
112
def get_appdata_location():
219
113
"""Return Application Data location.
220
114
Return None if we cannot obtain location.
222
Windows defines two 'Application Data' folders per user - a 'roaming'
223
one that moves with the user as they logon to different machines, and
224
a 'local' one that stays local to the machine. This returns the 'roaming'
225
directory, and thus is suitable for storing user-preferences, etc.
116
Returned value can be unicode or plain sring.
117
To convert plain string to unicode use
118
s.decode(bzrlib.user_encoding)
227
appdata = _get_sh_special_folder_path(CSIDL_APPDATA)
122
SHGetSpecialFolderPath = \
123
ctypes.windll.shell32.SHGetSpecialFolderPathW
124
except AttributeError:
127
buf = ctypes.create_unicode_buffer(MAX_PATH)
128
if SHGetSpecialFolderPath(None,buf,CSIDL_APPDATA,0):
131
appdata = os.environ.get('APPDATA')
230
# Use APPDATA if defined, will return None if not
231
return get_environ_unicode('APPDATA')
234
def get_local_appdata_location():
235
"""Return Local Application Data location.
236
Return the same as get_appdata_location() if we cannot obtain location.
238
Windows defines two 'Application Data' folders per user - a 'roaming'
239
one that moves with the user as they logon to different machines, and
240
a 'local' one that stays local to the machine. This returns the 'local'
241
directory, and thus is suitable for caches, temp files and other things
242
which don't need to move with the user.
244
local = _get_sh_special_folder_path(CSIDL_LOCAL_APPDATA)
247
# Vista supplies LOCALAPPDATA, but XP and earlier do not.
248
local = get_environ_unicode('LOCALAPPDATA')
251
return get_appdata_location()
134
# if we fall to this point we on win98
135
# at least try C:/WINDOWS/Application Data
136
windir = os.environ.get('windir')
138
appdata = os.path.join(windir, 'Application Data')
139
if os.path.isdir(appdata):
141
# did not find anything
254
145
def get_home_location():
288
192
buf = create_buffer(UNLEN+1)
289
193
n = ctypes.c_int(UNLEN+1)
290
194
if GetUserName(buf, ctypes.byref(n)):
291
return extract_buffer(buf)
292
196
# otherwise try env variables
293
return get_environ_unicode('USERNAME')
296
# 1 == ComputerNameDnsHostname, which returns "The DNS host name of the local
297
# computer or the cluster associated with the local computer."
298
_WIN32_ComputerNameDnsHostname = 1
197
return os.environ.get('USERNAME', None)
300
200
def get_host_name():
301
201
"""Return host machine name.
302
202
If name cannot be obtained return None.
304
:return: A unicode string representing the host name.
204
Returned value can be unicode or plain sring.
205
To convert plain string to unicode use
206
s.decode(bzrlib.user_encoding)
308
return win32api.GetComputerNameEx(_WIN32_ComputerNameDnsHostname)
309
except (NotImplementedError, win32api.error):
310
# NotImplemented will happen on win9x...
314
210
kernel32 = ctypes.windll.kernel32
211
GetComputerName = getattr(kernel32, 'GetComputerName'+suffix)
315
212
except AttributeError:
316
pass # Missing the module we need
318
215
buf = create_buffer(MAX_COMPUTERNAME_LENGTH+1)
319
216
n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
321
# Try GetComputerNameEx which gives a proper Unicode hostname
322
GetComputerNameEx = getattr(kernel32, 'GetComputerNameEx'+suffix,
324
if (GetComputerNameEx is not None
325
and GetComputerNameEx(_WIN32_ComputerNameDnsHostname,
326
buf, ctypes.byref(n))):
327
return extract_buffer(buf)
329
# Try GetComputerName in case GetComputerNameEx wasn't found
330
# It returns the NETBIOS name, which isn't as good, but still ok.
331
# The first GetComputerNameEx might have changed 'n', so reset it
332
n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
333
GetComputerName = getattr(kernel32, 'GetComputerName'+suffix,
335
if (GetComputerName is not None
336
and GetComputerName(buf, ctypes.byref(n))):
337
return extract_buffer(buf)
338
return get_environ_unicode('COMPUTERNAME')
341
def _ensure_with_dir(path):
342
if (not os.path.split(path)[0] or path.startswith(u'*')
343
or path.startswith(u'?')):
344
return u'./' + path, True
348
def _undo_ensure_with_dir(path, corrected):
355
def glob_one(possible_glob):
356
"""Same as glob.glob().
358
work around bugs in glob.glob()
359
- Python bug #1001604 ("glob doesn't return unicode with ...")
360
- failing expansion for */* with non-iso-8859-* chars
362
corrected_glob, corrected = _ensure_with_dir(possible_glob)
363
glob_files = glob.glob(corrected_glob)
366
# special case to let the normal code path handle
367
# files that do not exist, etc.
368
glob_files = [possible_glob]
370
glob_files = [_undo_ensure_with_dir(elem, corrected)
371
for elem in glob_files]
372
return [elem.replace(u'\\', u'/') for elem in glob_files]
375
def glob_expand(file_list):
376
"""Replacement for glob expansion by the shell.
378
Win32's cmd.exe does not do glob expansion (eg ``*.py``), so we do our own
381
:param file_list: A list of filenames which may include shell globs.
382
:return: An expanded list of filenames.
384
Introduced in breezy 0.18.
388
expanded_file_list = []
389
for possible_glob in file_list:
390
expanded_file_list.extend(glob_one(possible_glob))
391
return expanded_file_list
394
def get_app_path(appname):
395
r"""Look up in Windows registry for full path to application executable.
396
Typically, applications create subkey with their basename
397
in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\
399
:param appname: name of application (if no filename extension
400
is specified, .exe used)
401
:return: full path to aplication executable from registry,
402
or appname itself if nothing found.
407
if not os.path.splitext(basename)[1]:
408
basename = appname + '.exe'
411
hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
412
'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +
414
except EnvironmentError:
419
path, type_id = _winreg.QueryValueEx(hkey, '')
423
_winreg.CloseKey(hkey)
425
if type_id == REG_SZ:
427
if type_id == REG_EXPAND_SZ and has_win32api:
428
fullpath = win32api.ExpandEnvironmentStrings(path)
429
if len(fullpath) > 1 and fullpath[0] == '"' and fullpath[-1] == '"':
430
fullpath = fullpath[1:-1] # remove quotes around value
435
def set_file_attr_hidden(path):
436
"""Set file attributes to hidden if possible"""
438
SetFileAttributes = win32file.SetFileAttributesW
440
SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)
441
except pywintypes.error as e:
443
trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
446
def _command_line_to_argv(command_line, argv, single_quotes_allowed=False):
447
"""Convert a Unicode command line into a list of argv arguments.
449
It performs wildcard expansion to make wildcards act closer to how they
450
work in posix shells, versus how they work by default on Windows. Quoted
451
arguments are left untouched.
453
:param command_line: The unicode string to split into an arg list.
454
:param single_quotes_allowed: Whether single quotes are accepted as quoting
455
characters like double quotes. False by
457
:return: A list of unicode strings.
459
# First, split the command line
460
s = cmdline.Splitter(command_line, single_quotes_allowed=single_quotes_allowed)
462
# Bug #587868 Now make sure that the length of s agrees with sys.argv
463
# we do this by simply counting the number of arguments in each. The counts should
464
# agree no matter what encoding sys.argv is in (AFAIK)
465
# len(arguments) < len(sys.argv) should be an impossibility since python gets
466
# args from the very same PEB as does GetCommandLineW
469
# Now shorten the command line we get from GetCommandLineW to match sys.argv
470
if len(arguments) < len(argv):
471
raise AssertionError("Split command line can't be shorter than argv")
472
arguments = arguments[len(arguments) - len(argv):]
474
# Carry on to process globs (metachars) in the command line
475
# expand globs if necessary
476
# TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
479
for is_quoted, arg in arguments:
480
if is_quoted or not glob.has_magic(arg):
483
args.extend(glob_one(arg))
488
def get_unicode_argv():
489
prototype = ctypes.WINFUNCTYPE(ctypes.c_wchar_p)
490
GetCommandLineW = prototype(("GetCommandLineW",
491
ctypes.windll.kernel32))
492
command_line = GetCommandLineW()
493
if command_line is None:
494
raise ctypes.WinError()
495
# Skip the first argument, since we only care about parameters
496
argv = _command_line_to_argv(command_line, sys.argv)[1:]
500
def get_environ_unicode(key, default=None):
501
"""Get `key` from environment as unicode or `default` if unset
503
The environment is natively unicode on modern windows versions but
504
Python 2 only accesses it through the legacy bytestring api.
506
Environmental variable names are case insenstive on Windows.
508
A large enough buffer will be allocated to retrieve the value, though
509
it may take two calls to the underlying library function.
511
This needs ctypes because pywin32 does not expose the wide version.
513
cfunc = getattr(get_environ_unicode, "_c_function", None)
515
from ctypes.wintypes import DWORD, LPCWSTR, LPWSTR
516
cfunc = ctypes.WINFUNCTYPE(DWORD, LPCWSTR, LPWSTR, DWORD)(
517
("GetEnvironmentVariableW", ctypes.windll.kernel32))
518
get_environ_unicode._c_function = cfunc
519
buffer_size = 256 # heuristic, 256 characters often enough
521
buffer = ctypes.create_unicode_buffer(buffer_size)
522
length = cfunc(key, buffer, buffer_size)
524
code = ctypes.GetLastError()
525
if code == 203: # ERROR_ENVVAR_NOT_FOUND
527
raise ctypes.WinError(code)
528
if buffer_size > length:
529
return buffer[:length]
534
def _pywin32_is_local_pid_dead(pid):
535
"""True if pid doesn't correspond to live process on this machine"""
537
handle = win32api.OpenProcess(1, False, pid) # PROCESS_TERMINATE
538
except pywintypes.error as e:
539
if e[0] == 5: # ERROR_ACCESS_DENIED
540
# Probably something alive we're not allowed to kill
542
elif e[0] == 87: # ERROR_INVALID_PARAMETER
547
is_local_pid_dead = _pywin32_is_local_pid_dead
548
elif has_ctypes and sys.platform == 'win32':
549
from ctypes.wintypes import BOOL, DWORD, HANDLE
550
_kernel32 = ctypes.windll.kernel32
551
_CloseHandle = ctypes.WINFUNCTYPE(BOOL, HANDLE)(
552
("CloseHandle", _kernel32))
553
_OpenProcess = ctypes.WINFUNCTYPE(HANDLE, DWORD, BOOL, DWORD)(
554
("OpenProcess", _kernel32))
555
def _ctypes_is_local_pid_dead(pid):
556
"""True if pid doesn't correspond to live process on this machine"""
557
handle = _OpenProcess(1, False, pid) # PROCESS_TERMINATE
559
errorcode = ctypes.GetLastError()
560
if errorcode == 5: # ERROR_ACCESS_DENIED
561
# Probably something alive we're not allowed to kill
563
elif errorcode == 87: # ERROR_INVALID_PARAMETER
565
raise ctypes.WinError(errorcode)
568
is_local_pid_dead = _ctypes_is_local_pid_dead
571
def _is_pywintypes_error(evalue):
572
"""True if exception instance is an error from pywin32"""
573
if has_pywintypes and isinstance(evalue, pywintypes.error):
217
if GetComputerName(buf, ctypes.byref(n)):
219
# otherwise try env variables
220
return os.environ.get('COMPUTERNAME', None)
223
def _ensure_unicode(s):
224
if s and type(s) != unicode:
226
s = s.decode(bzrlib.user_encoding)
230
def get_appdata_location_unicode():
231
return _ensure_unicode(get_appdata_location())
233
def get_home_location_unicode():
234
return _ensure_unicode(get_home_location())
236
def get_user_name_unicode():
237
return _ensure_unicode(get_user_name())
239
def get_host_name_unicode():
240
return _ensure_unicode(get_host_name())
added
removed
bzrlib/win32utils.py
