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.
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':
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))
174
def get_console_size(defaultx=80, defaulty=25):
175
"""Return size of current console.
177
This function try to determine actual size of current working
178
console window and return tuple (sizex, sizey) if success,
179
or default size (defaultx, defaulty) otherwise.
183
return (defaultx, defaulty)
185
# To avoid problem with redirecting output via pipe
186
# we need to use stderr instead of stdout
187
h = ctypes.windll.kernel32.GetStdHandle(WIN32_STDERR_HANDLE)
188
csbi = ctypes.create_string_buffer(22)
189
res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
192
(bufx, bufy, curx, cury, wattr,
193
left, top, right, bottom, maxx, maxy) = struct.unpack(
194
"hhhhHhhhhhh", csbi.raw)
195
sizex = right - left + 1
196
sizey = bottom - top + 1
197
return (sizex, sizey)
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
237
def get_appdata_location():
238
"""Return Application Data location.
239
Return None if we cannot obtain location.
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.
247
To convert plain string to unicode use
248
s.decode(osutils.get_user_encoding())
249
(XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')
251
appdata = _get_sh_special_folder_path(CSIDL_APPDATA)
255
appdata = os.environ.get('APPDATA')
258
# if we fall to this point we on win98
259
# at least try C:/WINDOWS/Application Data
260
windir = os.environ.get('windir')
262
appdata = os.path.join(windir, 'Application Data')
263
if os.path.isdir(appdata):
265
# did not find anything
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()
294
def get_home_location():
295
"""Return user's home location.
296
Assume on win32 it's the <My Documents> folder.
297
If location cannot be obtained return system drive root,
300
Returned value can be unicode or plain string.
301
To convert plain string to unicode use
302
s.decode(osutils.get_user_encoding())
304
home = _get_sh_special_folder_path(CSIDL_PERSONAL)
307
# try for HOME env variable
308
home = os.path.expanduser('~')
311
# at least return windows root directory
312
windir = os.environ.get('windir')
314
return os.path.splitdrive(windir)[0] + '/'
315
# otherwise C:\ is good enough for 98% users
320
"""Return user name as login name.
321
If name cannot be obtained return None.
323
Returned value can be unicode or plain string.
324
To convert plain string to unicode use
325
s.decode(osutils.get_user_encoding())
329
advapi32 = ctypes.windll.advapi32
330
GetUserName = getattr(advapi32, 'GetUserName'+suffix)
331
except AttributeError:
334
buf = create_buffer(UNLEN+1)
335
n = ctypes.c_int(UNLEN+1)
336
if GetUserName(buf, ctypes.byref(n)):
338
# otherwise try env variables
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
347
"""Return host machine name.
348
If name cannot be obtained return None.
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...
361
kernel32 = ctypes.windll.kernel32
362
except AttributeError:
363
pass # Missing the module we need
365
buf = create_buffer(MAX_COMPUTERNAME_LENGTH+1)
366
n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
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")
396
def _ensure_unicode(s):
397
if s and type(s) != unicode:
398
from bzrlib import osutils
399
s = s.decode(osutils.get_user_encoding())
403
def get_appdata_location_unicode():
404
return _ensure_unicode(get_appdata_location())
406
def get_home_location_unicode():
407
return _ensure_unicode(get_home_location())
409
def get_user_name_unicode():
410
return _ensure_unicode(get_user_name())
412
def get_host_name_unicode():
413
return _ensure_unicode(get_host_name())
416
def _ensure_with_dir(path):
417
if (not os.path.split(path)[0] or path.startswith(u'*')
418
or path.startswith(u'?')):
419
return u'./' + path, True
423
def _undo_ensure_with_dir(path, corrected):
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]
451
def glob_expand(file_list):
452
"""Replacement for glob expansion by the shell.
454
Win32's cmd.exe does not do glob expansion (eg ``*.py``), so we do our own
457
:param file_list: A list of filenames which may include shell globs.
458
:return: An expanded list of filenames.
460
Introduced in bzrlib 0.18.
464
expanded_file_list = []
465
for possible_glob in file_list:
466
expanded_file_list.extend(glob_one(possible_glob))
467
return expanded_file_list
470
def get_app_path(appname):
471
"""Look up in Windows registry for full path to application executable.
472
Typically, applications create subkey with their basename
473
in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\
475
:param appname: name of application (if no filename extension
476
is specified, .exe used)
477
:return: full path to aplication executable from registry,
478
or appname itself if nothing found.
483
if not os.path.splitext(basename)[1]:
484
basename = appname + '.exe'
487
hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
488
'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +
490
except EnvironmentError:
495
path, type_id = _winreg.QueryValueEx(hkey, '')
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
511
def set_file_attr_hidden(path):
512
"""Set file attributes to hidden if possible"""
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)
526
class UnicodeShlex(object):
527
"""This is a very simplified version of shlex.shlex.
529
The main change is that it supports non-ascii input streams. The internal
530
structure is quite simplified relative to shlex.shlex, since we aren't
531
trying to handle multiple input streams, etc. In fact, we don't use a
532
file-like api either.
535
def __init__(self, uni_string):
536
self._input = uni_string
537
self._input_iter = iter(self._input)
538
self._whitespace_match = re.compile(u'\s').match
539
self._word_match = re.compile(u'\S').match
540
self._quote_chars = u'"'
541
# self._quote_match = re.compile(u'[\'"]').match
542
self._escape_match = lambda x: None # Never matches
545
# ' ' - after whitespace, starting a new token
546
# 'a' - after text, currently working on a token
547
# '"' - after ", currently in a "-delimited quoted section
548
# "\" - after '\', checking the next char
550
self._token = [] # Current token being parsed
552
def _get_token(self):
553
# Were there quote chars as part of this token?
556
for nextchar in self._input_iter:
557
if self._state == ' ':
558
if self._whitespace_match(nextchar):
559
# if self._token: return token
561
elif nextchar in self._quote_chars:
562
self._state = nextchar # quoted state
563
elif self._word_match(nextchar):
564
self._token.append(nextchar)
567
raise AssertionError('wtttf?')
568
elif self._state in self._quote_chars:
570
if nextchar == self._state: # End of quote
571
self._state = 'a' # posix allows 'foo'bar to translate to
573
elif self._state == '"' and nextchar == self._escape:
574
quoted_state = self._state
575
self._state = nextchar
577
self._token.append(nextchar)
578
elif self._state == self._escape:
580
self._token.append('\\')
581
elif nextchar == '"':
582
self._token.append(nextchar)
584
self._token.append('\\' + nextchar)
585
self._state = quoted_state
586
elif self._state == 'a':
587
if self._whitespace_match(nextchar):
589
break # emit this token
591
continue # no token to emit
592
elif nextchar in self._quote_chars:
593
# Start a new quoted section
594
self._state = nextchar
596
elif (self._word_match(nextchar)
597
or nextchar in self._quote_chars
598
# or whitespace_split?
600
self._token.append(nextchar)
602
raise AssertionError('state == "a", char: %r'
605
raise AssertionError('unknown state: %r' % (self._state,))
606
result = ''.join(self._token)
608
if not quoted and result == '':
610
return quoted, result
616
quoted, token = self._get_token()
622
def _command_line_to_argv(command_line):
623
"""Convert a Unicode command line into a set of argv arguments.
625
This does wildcard expansion, etc. It is intended to make wildcards act
626
closer to how they work in posix shells, versus how they work by default on
629
s = UnicodeShlex(command_line)
630
# Now that we've split the content, expand globs
631
# TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
634
for is_quoted, arg in s:
635
if is_quoted or not glob.has_magic(arg):
638
args.extend(glob_one(arg))
642
if has_ctypes and winver != 'Windows 98':
643
def get_unicode_argv():
644
LPCWSTR = ctypes.c_wchar_p
646
POINTER = ctypes.POINTER
647
prototype = ctypes.WINFUNCTYPE(LPCWSTR)
648
GetCommandLine = prototype(("GetCommandLineW",
649
ctypes.windll.kernel32))
650
prototype = ctypes.WINFUNCTYPE(POINTER(LPCWSTR), LPCWSTR, POINTER(INT))
651
command_line = GetCommandLine()
652
# Skip the first argument, since we only care about parameters
653
argv = _command_line_to_argv(command_line)[1:]
654
if getattr(sys, 'frozen', None) is None:
655
# Invoked via 'python.exe' which takes the form:
656
# python.exe [PYTHON_OPTIONS] C:\Path\bzr [BZR_OPTIONS]
657
# we need to get only BZR_OPTIONS part,
658
# We already removed 'python.exe' so we remove everything up to and
659
# including the first non-option ('-') argument.
660
for idx in xrange(len(argv)):
661
if argv[idx][:1] != '-':
666
get_unicode_argv = None
added
removed
bzrlib/win32utils.py
