13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
17
"""Win32-specific helper functions
19
19
Only one dependency: ctypes should be installed.
27
from bzrlib import cmdline
28
30
if sys.platform == 'win32':
87
100
MAX_COMPUTERNAME_LENGTH = 31
102
# Registry data type ids
107
def debug_memory_win32api(message='', short=True):
108
"""Use trace.note() to dump the running memory info."""
109
from bzrlib import trace
111
class PROCESS_MEMORY_COUNTERS_EX(ctypes.Structure):
112
"""Used by GetProcessMemoryInfo"""
113
_fields_ = [('cb', ctypes.c_ulong),
114
('PageFaultCount', ctypes.c_ulong),
115
('PeakWorkingSetSize', ctypes.c_size_t),
116
('WorkingSetSize', ctypes.c_size_t),
117
('QuotaPeakPagedPoolUsage', ctypes.c_size_t),
118
('QuotaPagedPoolUsage', ctypes.c_size_t),
119
('QuotaPeakNonPagedPoolUsage', ctypes.c_size_t),
120
('QuotaNonPagedPoolUsage', ctypes.c_size_t),
121
('PagefileUsage', ctypes.c_size_t),
122
('PeakPagefileUsage', ctypes.c_size_t),
123
('PrivateUsage', ctypes.c_size_t),
125
cur_process = ctypes.windll.kernel32.GetCurrentProcess()
126
mem_struct = PROCESS_MEMORY_COUNTERS_EX()
127
ret = ctypes.windll.psapi.GetProcessMemoryInfo(cur_process,
128
ctypes.byref(mem_struct),
129
ctypes.sizeof(mem_struct))
131
trace.note('Failed to GetProcessMemoryInfo()')
133
info = {'PageFaultCount': mem_struct.PageFaultCount,
134
'PeakWorkingSetSize': mem_struct.PeakWorkingSetSize,
135
'WorkingSetSize': mem_struct.WorkingSetSize,
136
'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,
137
'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,
138
'QuotaPeakNonPagedPoolUsage':
139
mem_struct.QuotaPeakNonPagedPoolUsage,
140
'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,
141
'PagefileUsage': mem_struct.PagefileUsage,
142
'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
143
'PrivateUsage': mem_struct.PrivateUsage,
147
# win32process does not return PrivateUsage, because it doesn't use
148
# PROCESS_MEMORY_COUNTERS_EX (it uses the one without _EX).
149
proc = win32process.GetCurrentProcess()
150
info = win32process.GetProcessMemoryInfo(proc)
152
trace.note('Cannot debug memory on win32 without ctypes'
156
# using base-2 units (see HACKING.txt).
157
trace.note('WorkingSize %7dKiB'
158
'\tPeakWorking %7dKiB\t%s',
159
info['WorkingSetSize'] / 1024,
160
info['PeakWorkingSetSize'] / 1024,
164
trace.note('%s', message)
165
trace.note('WorkingSize %8d KiB', info['WorkingSetSize'] / 1024)
166
trace.note('PeakWorking %8d KiB', info['PeakWorkingSetSize'] / 1024)
167
trace.note('PagefileUsage %8d KiB', info.get('PagefileUsage', 0) / 1024)
168
trace.note('PeakPagefileUsage %8d KiB',
169
info.get('PeakPagefileUsage', 0) / 1024)
170
trace.note('PrivateUsage %8d KiB', info.get('PrivateUsage', 0) / 1024)
171
trace.note('PageFaultCount %8d', info.get('PageFaultCount', 0))
90
174
def get_console_size(defaultx=80, defaulty=25):
91
175
"""Return size of current console.
99
183
return (defaultx, defaulty)
101
185
# To avoid problem with redirecting output via pipe
102
# need to use stderr instead of stdout
186
# we need to use stderr instead of stdout
103
187
h = ctypes.windll.kernel32.GetStdHandle(WIN32_STDERR_HANDLE)
104
188
csbi = ctypes.create_string_buffer(22)
105
189
res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
108
192
(bufx, bufy, curx, cury, wattr,
109
left, top, right, bottom, maxx, maxy) = struct.unpack("hhhhHhhhhhh", csbi.raw)
193
left, top, right, bottom, maxx, maxy) = struct.unpack(
194
"hhhhHhhhhhh", csbi.raw)
110
195
sizex = right - left + 1
111
196
sizey = bottom - top + 1
112
197
return (sizex, sizey)
114
199
return (defaultx, defaulty)
202
def _get_sh_special_folder_path(csidl):
203
"""Call SHGetSpecialFolderPathW if available, or return None.
205
Result is always unicode (or None).
209
SHGetSpecialFolderPath = \
210
ctypes.windll.shell32.SHGetSpecialFolderPathW
211
except AttributeError:
214
buf = ctypes.create_unicode_buffer(MAX_PATH)
215
if SHGetSpecialFolderPath(None,buf,csidl,0):
218
global has_win32com_shell
219
if has_win32com_shell is None:
221
from win32com.shell import shell
222
has_win32com_shell = True
224
has_win32com_shell = False
225
if has_win32com_shell:
226
# still need to bind the name locally, but this is fast.
227
from win32com.shell import shell
229
return shell.SHGetSpecialFolderPath(0, csidl, 0)
231
# possibly E_NOTIMPL meaning we can't load the function pointer,
232
# or E_FAIL meaning the function failed - regardless, just ignore it
117
237
def get_appdata_location():
118
238
"""Return Application Data location.
119
239
Return None if we cannot obtain location.
121
Returned value can be unicode or plain sring.
241
Windows defines two 'Application Data' folders per user - a 'roaming'
242
one that moves with the user as they logon to different machines, and
243
a 'local' one that stays local to the machine. This returns the 'roaming'
244
directory, and thus is suitable for storing user-preferences, etc.
246
Returned value can be unicode or plain string.
122
247
To convert plain string to unicode use
123
s.decode(bzrlib.user_encoding)
248
s.decode(osutils.get_user_encoding())
249
(XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')
127
SHGetSpecialFolderPath = \
128
ctypes.windll.shell32.SHGetSpecialFolderPathW
129
except AttributeError:
132
buf = ctypes.create_unicode_buffer(MAX_PATH)
133
if SHGetSpecialFolderPath(None,buf,CSIDL_APPDATA,0):
251
appdata = _get_sh_special_folder_path(CSIDL_APPDATA)
135
254
# from env variable
136
255
appdata = os.environ.get('APPDATA')
269
def get_local_appdata_location():
270
"""Return Local Application Data location.
271
Return the same as get_appdata_location() if we cannot obtain location.
273
Windows defines two 'Application Data' folders per user - a 'roaming'
274
one that moves with the user as they logon to different machines, and
275
a 'local' one that stays local to the machine. This returns the 'local'
276
directory, and thus is suitable for caches, temp files and other things
277
which don't need to move with the user.
279
Returned value can be unicode or plain string.
280
To convert plain string to unicode use
281
s.decode(osutils.get_user_encoding())
282
(XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')
284
local = _get_sh_special_folder_path(CSIDL_LOCAL_APPDATA)
287
# Vista supplies LOCALAPPDATA, but XP and earlier do not.
288
local = os.environ.get('LOCALAPPDATA')
291
return get_appdata_location()
150
294
def get_home_location():
151
295
"""Return user's home location.
152
296
Assume on win32 it's the <My Documents> folder.
153
297
If location cannot be obtained return system drive root,
156
Returned value can be unicode or plain sring.
300
Returned value can be unicode or plain string.
157
301
To convert plain string to unicode use
158
s.decode(bzrlib.user_encoding)
302
s.decode(osutils.get_user_encoding())
162
SHGetSpecialFolderPath = \
163
ctypes.windll.shell32.SHGetSpecialFolderPathW
164
except AttributeError:
167
buf = ctypes.create_unicode_buffer(MAX_PATH)
168
if SHGetSpecialFolderPath(None,buf,CSIDL_PERSONAL,0):
304
home = _get_sh_special_folder_path(CSIDL_PERSONAL)
170
307
# try for HOME env variable
171
308
home = os.path.expanduser('~')
202
339
return os.environ.get('USERNAME', None)
342
# 1 == ComputerNameDnsHostname, which returns "The DNS host name of the local
343
# computer or the cluster associated with the local computer."
344
_WIN32_ComputerNameDnsHostname = 1
205
346
def get_host_name():
206
347
"""Return host machine name.
207
348
If name cannot be obtained return None.
209
Returned value can be unicode or plain sring.
210
To convert plain string to unicode use
211
s.decode(bzrlib.user_encoding)
350
:return: A unicode string representing the host name. On win98, this may be
351
a plain string as win32 api doesn't support unicode.
355
return win32api.GetComputerNameEx(_WIN32_ComputerNameDnsHostname)
356
except (NotImplementedError, win32api.error):
357
# NotImplemented will happen on win9x...
215
361
kernel32 = ctypes.windll.kernel32
216
GetComputerName = getattr(kernel32, 'GetComputerName'+suffix)
217
362
except AttributeError:
363
pass # Missing the module we need
220
365
buf = create_buffer(MAX_COMPUTERNAME_LENGTH+1)
221
366
n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
222
if GetComputerName(buf, ctypes.byref(n)):
224
# otherwise try env variables
225
return os.environ.get('COMPUTERNAME', None)
368
# Try GetComputerNameEx which gives a proper Unicode hostname
369
GetComputerNameEx = getattr(kernel32, 'GetComputerNameEx'+suffix,
371
if (GetComputerNameEx is not None
372
and GetComputerNameEx(_WIN32_ComputerNameDnsHostname,
373
buf, ctypes.byref(n))):
376
# Try GetComputerName in case GetComputerNameEx wasn't found
377
# It returns the NETBIOS name, which isn't as good, but still ok.
378
# The first GetComputerNameEx might have changed 'n', so reset it
379
n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
380
GetComputerName = getattr(kernel32, 'GetComputerName'+suffix,
382
if (GetComputerName is not None
383
and GetComputerName(buf, ctypes.byref(n))):
385
# otherwise try env variables, which will be 'mbcs' encoded
386
# on Windows (Python doesn't expose the native win32 unicode environment)
388
# http://msdn.microsoft.com/en-us/library/aa246807.aspx
389
# environment variables should always be encoded in 'mbcs'.
391
return os.environ['COMPUTERNAME'].decode("mbcs")
228
396
def _ensure_unicode(s):
229
397
if s and type(s) != unicode:
231
s = s.decode(bzrlib.user_encoding)
398
from bzrlib import osutils
399
s = s.decode(osutils.get_user_encoding())
235
403
def get_appdata_location_unicode():
236
404
return _ensure_unicode(get_appdata_location())
431
def glob_one(possible_glob):
432
"""Same as glob.glob().
434
work around bugs in glob.glob()
435
- Python bug #1001604 ("glob doesn't return unicode with ...")
436
- failing expansion for */* with non-iso-8859-* chars
438
corrected_glob, corrected = _ensure_with_dir(possible_glob)
439
glob_files = glob.glob(corrected_glob)
442
# special case to let the normal code path handle
443
# files that do not exist, etc.
444
glob_files = [possible_glob]
446
glob_files = [_undo_ensure_with_dir(elem, corrected)
447
for elem in glob_files]
448
return [elem.replace(u'\\', u'/') for elem in glob_files]
262
451
def glob_expand(file_list):
263
452
"""Replacement for glob expansion by the shell.
273
462
if not file_list:
276
464
expanded_file_list = []
277
465
for possible_glob in file_list:
279
# work around bugs in glob.glob()
280
# - Python bug #1001604 ("glob doesn't return unicode with ...")
281
# - failing expansion for */* with non-iso-8859-* chars
282
possible_glob, corrected = _ensure_with_dir(possible_glob)
283
glob_files = glob.glob(possible_glob)
286
# special case to let the normal code path handle
287
# files that do not exists
288
expanded_file_list.append(
289
_undo_ensure_with_dir(possible_glob, corrected))
291
glob_files = [_undo_ensure_with_dir(elem, corrected) for elem in glob_files]
292
expanded_file_list += glob_files
294
return [elem.replace(u'\\', u'/') for elem in expanded_file_list]
466
expanded_file_list.extend(glob_one(possible_glob))
467
return expanded_file_list
297
470
def get_app_path(appname):
298
471
"""Look up in Windows registry for full path to application executable.
299
Typicaly, applications create subkey with their basename
472
Typically, applications create subkey with their basename
300
473
in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\
302
475
:param appname: name of application (if no filename extension
305
478
or appname itself if nothing found.
483
if not os.path.splitext(basename)[1]:
484
basename = appname + '.exe'
309
487
hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
310
r'SOFTWARE\Microsoft\Windows'
311
r'\CurrentVersion\App Paths')
488
'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +
312
490
except EnvironmentError:
316
if not os.path.splitext(basename)[1]:
317
basename = appname + '.exe'
320
fullpath = _winreg.QueryValue(hkey, basename)
495
path, type_id = _winreg.QueryValueEx(hkey, '')
321
496
except WindowsError:
324
499
_winreg.CloseKey(hkey)
501
if type_id == REG_SZ:
503
if type_id == REG_EXPAND_SZ and has_win32api:
504
fullpath = win32api.ExpandEnvironmentStrings(path)
505
if len(fullpath) > 1 and fullpath[0] == '"' and fullpath[-1] == '"':
506
fullpath = fullpath[1:-1] # remove quotes around value
329
511
def set_file_attr_hidden(path):
330
512
"""Set file attributes to hidden if possible"""
331
513
if has_win32file:
332
win32file.SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)
514
if winver != 'Windows 98':
515
SetFileAttributes = win32file.SetFileAttributesW
517
SetFileAttributes = win32file.SetFileAttributes
519
SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)
520
except pywintypes.error, e:
521
from bzrlib import trace
522
trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
525
def _command_line_to_argv(command_line, single_quotes_allowed=False):
526
"""Convert a Unicode command line into a list of argv arguments.
528
It performs wildcard expansion to make wildcards act closer to how they
529
work in posix shells, versus how they work by default on Windows. Quoted
530
arguments are left untouched.
532
:param command_line: The unicode string to split into an arg list.
533
:param single_quotes_allowed: Whether single quotes are accepted as quoting
534
characters like double quotes. False by
536
:return: A list of unicode strings.
538
s = cmdline.Splitter(command_line, single_quotes_allowed=single_quotes_allowed)
539
# Now that we've split the content, expand globs if necessary
540
# TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
543
for is_quoted, arg in s:
544
if is_quoted or not glob.has_magic(arg):
547
args.extend(glob_one(arg))
551
if has_ctypes and winver != 'Windows 98':
552
def get_unicode_argv():
553
prototype = ctypes.WINFUNCTYPE(ctypes.c_wchar_p)
554
GetCommandLineW = prototype(("GetCommandLineW",
555
ctypes.windll.kernel32))
556
command_line = GetCommandLineW()
557
if command_line is None:
558
raise ctypes.WinError()
559
# Skip the first argument, since we only care about parameters
560
argv = _command_line_to_argv(command_line)[1:]
561
if getattr(sys, 'frozen', None) is None:
562
# Invoked via 'python.exe' which takes the form:
563
# python.exe [PYTHON_OPTIONS] C:\Path\bzr [BZR_OPTIONS]
564
# we need to get only BZR_OPTIONS part,
565
# We already removed 'python.exe' so we remove everything up to and
566
# including the first non-option ('-') argument.
567
for idx in xrange(len(argv)):
568
if argv[idx][:1] != '-':
573
get_unicode_argv = None
added
removed
bzrlib/win32utils.py
