1
# Copyright (C) 2006, 2007 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.
30
if sys.platform == 'win32':
31
_major,_minor,_build,_platform,_text = sys.getwindowsversion()
34
# The operating system platform.
35
# This member can be one of the following values.
36
# ========================== ======================================
38
# -------------------------- --------------------------------------
39
# VER_PLATFORM_WIN32_NT The operating system is Windows Vista,
40
# 2 Windows Server "Longhorn",
41
# Windows Server 2003, Windows XP,
42
# Windows 2000, or Windows NT.
44
# VER_PLATFORM_WIN32_WINDOWS The operating system is Windows Me,
45
# 1 Windows 98, or Windows 95.
46
# ========================== ======================================
50
# don't care about real Windows name, just to force safe operations
56
# We can cope without it; use a separate variable to help pyflakes
63
if winver == 'Windows 98':
64
create_buffer = ctypes.create_string_buffer
67
create_buffer = ctypes.create_unicode_buffer
81
# pulling in win32com.shell is a bit of overhead, and normally we don't need
82
# it as ctypes is preferred and common. lazy_imports and "optional"
83
# modules don't work well, so we do our own lazy thing...
84
has_win32com_shell = None # Set to True or False once we know for sure...
86
# Special Win32 API constants
87
# Handles of std streams
88
WIN32_STDIN_HANDLE = -10
89
WIN32_STDOUT_HANDLE = -11
90
WIN32_STDERR_HANDLE = -12
92
# CSIDL constants (from MSDN 2003)
93
CSIDL_APPDATA = 0x001A # Application Data folder
94
CSIDL_LOCAL_APPDATA = 0x001c# <user name>\Local Settings\Application Data (non roaming)
95
CSIDL_PERSONAL = 0x0005 # My Documents folder
97
# from winapi C headers
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': mem_struct.QuotaPeakNonPagedPoolUsage,
139
'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,
140
'PagefileUsage': mem_struct.PagefileUsage,
141
'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
142
'PrivateUsage': mem_struct.PrivateUsage,
146
# win32process does not return PrivateUsage, because it doesn't use
147
# PROCESS_MEMORY_COUNTERS_EX (it uses the one without _EX).
148
proc = win32process.GetCurrentProcess()
149
info = win32process.GetProcessMemoryInfo(proc)
151
trace.note('Cannot debug memory on win32 without ctypes'
155
trace.note('WorkingSize %7dKB'
156
'\tPeakWorking %7dKB\t%s',
157
info['WorkingSetSize'] / 1024,
158
info['PeakWorkingSetSize'] / 1024,
162
trace.note('%s', message)
163
trace.note('WorkingSize %8d KB', info['WorkingSetSize'] / 1024)
164
trace.note('PeakWorking %8d KB', info['PeakWorkingSetSize'] / 1024)
165
trace.note('PagefileUsage %8d KB', info.get('PagefileUsage', 0) / 1024)
166
trace.note('PeakPagefileUsage %8d KB', info.get('PeakPagefileUsage', 0) / 1024)
167
trace.note('PrivateUsage %8d KB', info.get('PrivateUsage', 0) / 1024)
168
trace.note('PageFaultCount %8d', info.get('PageFaultCount', 0))
171
def get_console_size(defaultx=80, defaulty=25):
172
"""Return size of current console.
174
This function try to determine actual size of current working
175
console window and return tuple (sizex, sizey) if success,
176
or default size (defaultx, defaulty) otherwise.
180
return (defaultx, defaulty)
182
# To avoid problem with redirecting output via pipe
183
# we need to use stderr instead of stdout
184
h = ctypes.windll.kernel32.GetStdHandle(WIN32_STDERR_HANDLE)
185
csbi = ctypes.create_string_buffer(22)
186
res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
189
(bufx, bufy, curx, cury, wattr,
190
left, top, right, bottom, maxx, maxy) = struct.unpack("hhhhHhhhhhh", csbi.raw)
191
sizex = right - left + 1
192
sizey = bottom - top + 1
193
return (sizex, sizey)
195
return (defaultx, defaulty)
198
def _get_sh_special_folder_path(csidl):
199
"""Call SHGetSpecialFolderPathW if available, or return None.
201
Result is always unicode (or None).
205
SHGetSpecialFolderPath = \
206
ctypes.windll.shell32.SHGetSpecialFolderPathW
207
except AttributeError:
210
buf = ctypes.create_unicode_buffer(MAX_PATH)
211
if SHGetSpecialFolderPath(None,buf,csidl,0):
214
global has_win32com_shell
215
if has_win32com_shell is None:
217
from win32com.shell import shell
218
has_win32com_shell = True
220
has_win32com_shell = False
221
if has_win32com_shell:
222
# still need to bind the name locally, but this is fast.
223
from win32com.shell import shell
225
return shell.SHGetSpecialFolderPath(0, csidl, 0)
227
# possibly E_NOTIMPL meaning we can't load the function pointer,
228
# or E_FAIL meaning the function failed - regardless, just ignore it
233
def get_appdata_location():
234
"""Return Application Data location.
235
Return None if we cannot obtain location.
237
Windows defines two 'Application Data' folders per user - a 'roaming'
238
one that moves with the user as they logon to different machines, and
239
a 'local' one that stays local to the machine. This returns the 'roaming'
240
directory, and thus is suitable for storing user-preferences, etc.
242
Returned value can be unicode or plain string.
243
To convert plain string to unicode use
244
s.decode(osutils.get_user_encoding())
245
(XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')
247
appdata = _get_sh_special_folder_path(CSIDL_APPDATA)
251
appdata = os.environ.get('APPDATA')
254
# if we fall to this point we on win98
255
# at least try C:/WINDOWS/Application Data
256
windir = os.environ.get('windir')
258
appdata = os.path.join(windir, 'Application Data')
259
if os.path.isdir(appdata):
261
# did not find anything
265
def get_local_appdata_location():
266
"""Return Local Application Data location.
267
Return the same as get_appdata_location() if we cannot obtain location.
269
Windows defines two 'Application Data' folders per user - a 'roaming'
270
one that moves with the user as they logon to different machines, and
271
a 'local' one that stays local to the machine. This returns the 'local'
272
directory, and thus is suitable for caches, temp files and other things
273
which don't need to move with the user.
275
Returned value can be unicode or plain string.
276
To convert plain string to unicode use
277
s.decode(osutils.get_user_encoding())
278
(XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')
280
local = _get_sh_special_folder_path(CSIDL_LOCAL_APPDATA)
283
# Vista supplies LOCALAPPDATA, but XP and earlier do not.
284
local = os.environ.get('LOCALAPPDATA')
287
return get_appdata_location()
290
def get_home_location():
291
"""Return user's home location.
292
Assume on win32 it's the <My Documents> folder.
293
If location cannot be obtained return system drive root,
296
Returned value can be unicode or plain string.
297
To convert plain string to unicode use
298
s.decode(osutils.get_user_encoding())
300
home = _get_sh_special_folder_path(CSIDL_PERSONAL)
303
# try for HOME env variable
304
home = os.path.expanduser('~')
307
# at least return windows root directory
308
windir = os.environ.get('windir')
310
return os.path.splitdrive(windir)[0] + '/'
311
# otherwise C:\ is good enough for 98% users
316
"""Return user name as login name.
317
If name cannot be obtained return None.
319
Returned value can be unicode or plain string.
320
To convert plain string to unicode use
321
s.decode(osutils.get_user_encoding())
325
advapi32 = ctypes.windll.advapi32
326
GetUserName = getattr(advapi32, 'GetUserName'+suffix)
327
except AttributeError:
330
buf = create_buffer(UNLEN+1)
331
n = ctypes.c_int(UNLEN+1)
332
if GetUserName(buf, ctypes.byref(n)):
334
# otherwise try env variables
335
return os.environ.get('USERNAME', None)
338
# 1 == ComputerNameDnsHostname, which returns "The DNS host name of the local
339
# computer or the cluster associated with the local computer."
340
_WIN32_ComputerNameDnsHostname = 1
343
"""Return host machine name.
344
If name cannot be obtained return None.
346
:return: A unicode string representing the host name. On win98, this may be
347
a plain string as win32 api doesn't support unicode.
351
return win32api.GetComputerNameEx(_WIN32_ComputerNameDnsHostname)
352
except (NotImplementedError, win32api.error):
353
# NotImplemented will happen on win9x...
357
kernel32 = ctypes.windll.kernel32
358
except AttributeError:
359
pass # Missing the module we need
361
buf = create_buffer(MAX_COMPUTERNAME_LENGTH+1)
362
n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
364
# Try GetComputerNameEx which gives a proper Unicode hostname
365
GetComputerNameEx = getattr(kernel32, 'GetComputerNameEx'+suffix,
367
if (GetComputerNameEx is not None
368
and GetComputerNameEx(_WIN32_ComputerNameDnsHostname,
369
buf, ctypes.byref(n))):
372
# Try GetComputerName in case GetComputerNameEx wasn't found
373
# It returns the NETBIOS name, which isn't as good, but still ok.
374
# The first GetComputerNameEx might have changed 'n', so reset it
375
n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
376
GetComputerName = getattr(kernel32, 'GetComputerName'+suffix,
378
if (GetComputerName is not None
379
and GetComputerName(buf, ctypes.byref(n))):
381
# otherwise try env variables, which will be 'mbcs' encoded
382
# on Windows (Python doesn't expose the native win32 unicode environment)
384
# http://msdn.microsoft.com/en-us/library/aa246807.aspx
385
# environment variables should always be encoded in 'mbcs'.
387
return os.environ['COMPUTERNAME'].decode("mbcs")
392
def _ensure_unicode(s):
393
if s and type(s) != unicode:
394
from bzrlib import osutils
395
s = s.decode(osutils.get_user_encoding())
399
def get_appdata_location_unicode():
400
return _ensure_unicode(get_appdata_location())
402
def get_home_location_unicode():
403
return _ensure_unicode(get_home_location())
405
def get_user_name_unicode():
406
return _ensure_unicode(get_user_name())
408
def get_host_name_unicode():
409
return _ensure_unicode(get_host_name())
412
def _ensure_with_dir(path):
413
if not os.path.split(path)[0] or path.startswith(u'*') or path.startswith(u'?'):
414
return u'./' + path, True
418
def _undo_ensure_with_dir(path, corrected):
426
def glob_one(possible_glob):
427
"""Same as glob.glob().
429
work around bugs in glob.glob()
430
- Python bug #1001604 ("glob doesn't return unicode with ...")
431
- failing expansion for */* with non-iso-8859-* chars
433
corrected_glob, corrected = _ensure_with_dir(possible_glob)
434
glob_files = glob.glob(corrected_glob)
437
# special case to let the normal code path handle
438
# files that do not exist, etc.
439
glob_files = [possible_glob]
441
glob_files = [_undo_ensure_with_dir(elem, corrected)
442
for elem in glob_files]
443
return [elem.replace(u'\\', u'/') for elem in glob_files]
446
def glob_expand(file_list):
447
"""Replacement for glob expansion by the shell.
449
Win32's cmd.exe does not do glob expansion (eg ``*.py``), so we do our own
452
:param file_list: A list of filenames which may include shell globs.
453
:return: An expanded list of filenames.
455
Introduced in bzrlib 0.18.
459
expanded_file_list = []
460
for possible_glob in file_list:
461
expanded_file_list.extend(glob_one(possible_glob))
462
return expanded_file_list
465
def get_app_path(appname):
466
"""Look up in Windows registry for full path to application executable.
467
Typically, applications create subkey with their basename
468
in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\
470
:param appname: name of application (if no filename extension
471
is specified, .exe used)
472
:return: full path to aplication executable from registry,
473
or appname itself if nothing found.
478
if not os.path.splitext(basename)[1]:
479
basename = appname + '.exe'
482
hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
483
'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +
485
except EnvironmentError:
490
path, type_id = _winreg.QueryValueEx(hkey, '')
494
_winreg.CloseKey(hkey)
496
if type_id == REG_SZ:
498
if type_id == REG_EXPAND_SZ and has_win32api:
499
fullpath = win32api.ExpandEnvironmentStrings(path)
500
if len(fullpath) > 1 and fullpath[0] == '"' and fullpath[-1] == '"':
501
fullpath = fullpath[1:-1] # remove quotes around value
506
def set_file_attr_hidden(path):
507
"""Set file attributes to hidden if possible"""
509
if winver != 'Windows 98':
510
SetFileAttributes = win32file.SetFileAttributesW
512
SetFileAttributes = win32file.SetFileAttributes
514
SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)
515
except pywintypes.error, e:
516
from bzrlib import trace
517
trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
520
_whitespace_match = re.compile(u'\s').match
523
class _PushbackSequence(object):
524
def __init__(self, orig):
525
self._iter = iter(orig)
526
self._pushback_buffer = []
529
if len(self._pushback_buffer) > 0:
530
return self._pushback_buffer.pop()
532
return self._iter.next()
534
def pushback(self, char):
535
self._pushback_buffer.append(char)
541
class _Whitespace(object):
542
def process(self, next_char, seq, context):
543
if _whitespace_match(next_char):
544
if len(context.token) > 0:
548
elif (next_char == u'"'
549
or (context.single_quotes_allowed and next_char == u"'")):
550
context.quoted = True
551
return _Quotes(next_char, self)
552
elif next_char == u'\\':
553
return _Backslash(self)
555
context.token.append(next_char)
559
class _Quotes(object):
560
def __init__(self, quote_char, exit_state):
561
self.quote_char = quote_char
562
self.exit_state = exit_state
564
def process(self, next_char, seq, context):
565
if next_char == u'\\':
566
return _Backslash(self)
567
elif next_char == self.quote_char:
568
return self.exit_state
570
context.token.append(next_char)
574
class _Backslash(object):
575
# See http://msdn.microsoft.com/en-us/library/bb776391(VS.85).aspx
576
def __init__(self, exit_state):
577
self.exit_state = exit_state
580
def process(self, next_char, seq, context):
581
if next_char == u'\\':
584
elif next_char == u'"':
585
# 2N backslashes followed by '"' are N backslashes
586
context.token.append(u'\\' * (self.count/2))
587
# 2N+1 backslashes follwed by '"' are N backslashes followed by '"'
588
# which should not be processed as the start or end of quoted arg
589
if self.count % 2 == 1:
590
context.token.append(next_char) # odd number of '\' escapes the '"'
592
seq.pushback(next_char) # let exit_state handle next_char
594
return self.exit_state
596
# N backslashes not followed by '"' are just N backslashes
598
context.token.append(u'\\' * self.count)
600
seq.pushback(next_char) # let exit_state handle next_char
601
return self.exit_state
603
def finish(self, context):
605
context.token.append(u'\\' * self.count)
609
def process(self, next_char, seq, context):
610
if _whitespace_match(next_char):
612
elif (next_char == u'"'
613
or (context.single_quotes_allowed and next_char == u"'")):
614
return _Quotes(next_char, self)
615
elif next_char == u'\\':
616
return _Backslash(self)
618
context.token.append(next_char)
622
class UnicodeShlex(object):
623
def __init__(self, command_line, single_quotes_allowed=False):
624
self._seq = _PushbackSequence(command_line)
625
self.single_quotes_allowed = single_quotes_allowed
631
quoted, token = self._get_token()
636
def _get_token(self):
639
state = _Whitespace()
640
for next_char in self._seq:
641
state = state.process(next_char, self._seq, self)
644
if not state is None and not getattr(state, 'finish', None) is None:
646
result = u''.join(self.token)
647
if not self.quoted and result == '':
649
return self.quoted, result
652
def command_line_to_argv(command_line, wildcard_expansion=True,
653
single_quotes_allowed=False):
654
"""Convert a Unicode command line into a list of argv arguments.
656
This optionally does wildcard expansion, etc. It is intended to make
657
wildcards act closer to how they work in posix shells, versus how they
658
work by default on Windows. Quoted arguments are left untouched.
660
:param command_line: The unicode string to split into an arg list.
661
:param wildcard_expansion: Whether wildcard expansion should be applied to
662
each argument. True by default.
663
:param single_quotes_allowed: Whether single quotes are accepted as quoting
664
characters like double quotes. False by
666
:return: A list of unicode strings.
668
s = UnicodeShlex(command_line, single_quotes_allowed=single_quotes_allowed)
669
# Now that we've split the content, expand globs if necessary
670
# TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
673
for is_quoted, arg in s:
674
if is_quoted or not glob.has_magic(arg) or not wildcard_expansion:
677
args.extend(glob_one(arg))
681
if has_ctypes and winver != 'Windows 98':
682
def get_unicode_argv():
683
prototype = ctypes.WINFUNCTYPE(ctypes.c_wchar_p, use_last_error=True)
684
GetCommandLineW = prototype(("GetCommandLineW",
685
ctypes.windll.kernel32))
686
command_line = GetCommandLineW()
687
if command_line is None:
688
raise ctypes.WinError()
689
# Skip the first argument, since we only care about parameters
690
argv = command_line_to_argv(command_line)[1:]
691
if getattr(sys, 'frozen', None) is None:
692
# Invoked via 'python.exe' which takes the form:
693
# python.exe [PYTHON_OPTIONS] C:\Path\bzr [BZR_OPTIONS]
694
# we need to get only BZR_OPTIONS part,
695
# We already removed 'python.exe' so we remove everything up to and
696
# including the first non-option ('-') argument.
697
for idx in xrange(len(argv)):
698
if argv[idx][:1] != '-':
703
get_unicode_argv = None
added
removed
bzrlib/win32utils.py
