← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/win32utils.py

  • Committer: Patch Queue Manager
  • Date: 2016-04-21 04:10:52 UTC
  • mfrom: (6616.1.1 fix-en-user-guide)
  • Revision ID: pqm@pqm.ubuntu.com-20160421041052-clcye7ns1qcl2n7w
(richard-wilbur) Ensure build of English use guide always uses English text
 even when user's locale specifies a different language. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/win32utils.py
1
 
# Copyright (C) 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2005-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
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
16
16
 
17
17
"""Win32-specific helper functions
18
18
 
19
19
Only one dependency: ctypes should be installed.
20
20
"""
21
21
 
 
22
from __future__ import absolute_import
 
23
 
 
24
import glob
 
25
import operator
22
26
import os
23
27
import struct
24
28
import sys
25
29
 
 
30
from bzrlib import (
 
31
    cmdline,
 
32
    symbol_versioning,
 
33
    )
 
34
from bzrlib.i18n import gettext
26
35
 
27
36
# Windows version
28
37
if sys.platform == 'win32':
60
69
else:
61
70
    if winver == 'Windows 98':
62
71
        create_buffer = ctypes.create_string_buffer
 
72
        def extract_buffer(buf):
 
73
            return buf.value.decode("mbcs")
63
74
        suffix = 'A'
64
75
    else:
65
76
        create_buffer = ctypes.create_unicode_buffer
 
77
        extract_buffer = operator.attrgetter("value")
66
78
        suffix = 'W'
67
79
try:
68
 
    import win32file
69
 
    has_win32file = True
 
80
    import pywintypes
 
81
    has_pywintypes = True
70
82
except ImportError:
71
 
    has_win32file = False
 
83
    has_pywintypes = has_win32file = has_win32api = False
 
84
else:
 
85
    try:
 
86
        import win32file
 
87
        has_win32file = True
 
88
    except ImportError:
 
89
        has_win32file = False
 
90
    try:
 
91
        import win32api
 
92
        has_win32api = True
 
93
    except ImportError:
 
94
        has_win32api = False
72
95
 
 
96
# pulling in win32com.shell is a bit of overhead, and normally we don't need
 
97
# it as ctypes is preferred and common.  lazy_imports and "optional"
 
98
# modules don't work well, so we do our own lazy thing...
 
99
has_win32com_shell = None # Set to True or False once we know for sure...
73
100
 
74
101
# Special Win32 API constants
75
102
# Handles of std streams
79
106
 
80
107
# CSIDL constants (from MSDN 2003)
81
108
CSIDL_APPDATA = 0x001A      # Application Data folder
 
109
CSIDL_LOCAL_APPDATA = 0x001c# <user name>\Local Settings\Application Data (non roaming)
82
110
CSIDL_PERSONAL = 0x0005     # My Documents folder
83
111
 
84
112
# from winapi C headers
86
114
UNLEN = 256
87
115
MAX_COMPUTERNAME_LENGTH = 31
88
116
 
 
117
# Registry data type ids
 
118
REG_SZ = 1
 
119
REG_EXPAND_SZ = 2
 
120
 
 
121
 
 
122
def debug_memory_win32api(message='', short=True):
 
123
    """Use trace.note() to dump the running memory info."""
 
124
    from bzrlib import trace
 
125
    if has_ctypes:
 
126
        class PROCESS_MEMORY_COUNTERS_EX(ctypes.Structure):
 
127
            """Used by GetProcessMemoryInfo"""
 
128
            _fields_ = [('cb', ctypes.c_ulong),
 
129
                        ('PageFaultCount', ctypes.c_ulong),
 
130
                        ('PeakWorkingSetSize', ctypes.c_size_t),
 
131
                        ('WorkingSetSize', ctypes.c_size_t),
 
132
                        ('QuotaPeakPagedPoolUsage', ctypes.c_size_t),
 
133
                        ('QuotaPagedPoolUsage', ctypes.c_size_t),
 
134
                        ('QuotaPeakNonPagedPoolUsage', ctypes.c_size_t),
 
135
                        ('QuotaNonPagedPoolUsage', ctypes.c_size_t),
 
136
                        ('PagefileUsage', ctypes.c_size_t),
 
137
                        ('PeakPagefileUsage', ctypes.c_size_t),
 
138
                        ('PrivateUsage', ctypes.c_size_t),
 
139
                       ]
 
140
        cur_process = ctypes.windll.kernel32.GetCurrentProcess()
 
141
        mem_struct = PROCESS_MEMORY_COUNTERS_EX()
 
142
        ret = ctypes.windll.psapi.GetProcessMemoryInfo(cur_process,
 
143
            ctypes.byref(mem_struct),
 
144
            ctypes.sizeof(mem_struct))
 
145
        if not ret:
 
146
            trace.note(gettext('Failed to GetProcessMemoryInfo()'))
 
147
            return
 
148
        info = {'PageFaultCount': mem_struct.PageFaultCount,
 
149
                'PeakWorkingSetSize': mem_struct.PeakWorkingSetSize,
 
150
                'WorkingSetSize': mem_struct.WorkingSetSize,
 
151
                'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,
 
152
                'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,
 
153
                'QuotaPeakNonPagedPoolUsage':
 
154
                    mem_struct.QuotaPeakNonPagedPoolUsage,
 
155
                'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,
 
156
                'PagefileUsage': mem_struct.PagefileUsage,
 
157
                'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
 
158
                'PrivateUsage': mem_struct.PrivateUsage,
 
159
               }
 
160
    elif has_win32api:
 
161
        import win32process
 
162
        # win32process does not return PrivateUsage, because it doesn't use
 
163
        # PROCESS_MEMORY_COUNTERS_EX (it uses the one without _EX).
 
164
        proc = win32process.GetCurrentProcess()
 
165
        info = win32process.GetProcessMemoryInfo(proc)
 
166
    else:
 
167
        trace.note(gettext('Cannot debug memory on win32 without ctypes'
 
168
                   ' or win32process'))
 
169
        return
 
170
    if short:
 
171
        # using base-2 units (see HACKING.txt).
 
172
        trace.note(gettext('WorkingSize {0:>7}KiB'
 
173
                   '\tPeakWorking {1:>7}KiB\t{2}').format(
 
174
                   info['WorkingSetSize'] / 1024,
 
175
                   info['PeakWorkingSetSize'] / 1024,
 
176
                   message))
 
177
        return
 
178
    if message:
 
179
        trace.note('%s', message)
 
180
    trace.note(gettext('WorkingSize       %8d KiB'), info['WorkingSetSize'] / 1024)
 
181
    trace.note(gettext('PeakWorking       %8d KiB'), info['PeakWorkingSetSize'] / 1024)
 
182
    trace.note(gettext('PagefileUsage     %8d KiB'), info.get('PagefileUsage', 0) / 1024)
 
183
    trace.note(gettext('PeakPagefileUsage %8d KiB'),
 
184
               info.get('PeakPagefileUsage', 0) / 1024)
 
185
    trace.note(gettext('PrivateUsage      %8d KiB'), info.get('PrivateUsage', 0) / 1024)
 
186
    trace.note(gettext('PageFaultCount    %8d'), info.get('PageFaultCount', 0))
 
187
 
89
188
 
90
189
def get_console_size(defaultx=80, defaulty=25):
91
190
    """Return size of current console.
99
198
        return (defaultx, defaulty)
100
199
 
101
200
    # To avoid problem with redirecting output via pipe
102
 
    # need to use stderr instead of stdout
 
201
    # we need to use stderr instead of stdout
103
202
    h = ctypes.windll.kernel32.GetStdHandle(WIN32_STDERR_HANDLE)
104
203
    csbi = ctypes.create_string_buffer(22)
105
204
    res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
106
205
 
107
206
    if res:
108
207
        (bufx, bufy, curx, cury, wattr,
109
 
        left, top, right, bottom, maxx, maxy) = struct.unpack("hhhhHhhhhhh", csbi.raw)
 
208
        left, top, right, bottom, maxx, maxy) = struct.unpack(
 
209
            "hhhhHhhhhhh", csbi.raw)
110
210
        sizex = right - left + 1
111
211
        sizey = bottom - top + 1
112
212
        return (sizex, sizey)
114
214
        return (defaultx, defaulty)
115
215
 
116
216
 
 
217
def _get_sh_special_folder_path(csidl):
 
218
    """Call SHGetSpecialFolderPathW if available, or return None.
 
219
 
 
220
    Result is always unicode (or None).
 
221
    """
 
222
    if has_ctypes:
 
223
        try:
 
224
            SHGetSpecialFolderPath = \
 
225
                ctypes.windll.shell32.SHGetSpecialFolderPathW
 
226
        except AttributeError:
 
227
            pass
 
228
        else:
 
229
            buf = ctypes.create_unicode_buffer(MAX_PATH)
 
230
            if SHGetSpecialFolderPath(None,buf,csidl,0):
 
231
                return buf.value
 
232
 
 
233
    global has_win32com_shell
 
234
    if has_win32com_shell is None:
 
235
        try:
 
236
            from win32com.shell import shell
 
237
            has_win32com_shell = True
 
238
        except ImportError:
 
239
            has_win32com_shell = False
 
240
    if has_win32com_shell:
 
241
        # still need to bind the name locally, but this is fast.
 
242
        from win32com.shell import shell
 
243
        try:
 
244
            return shell.SHGetSpecialFolderPath(0, csidl, 0)
 
245
        except shell.error:
 
246
            # possibly E_NOTIMPL meaning we can't load the function pointer,
 
247
            # or E_FAIL meaning the function failed - regardless, just ignore it
 
248
            pass
 
249
    return None
 
250
 
 
251
 
117
252
def get_appdata_location():
118
253
    """Return Application Data location.
119
254
    Return None if we cannot obtain location.
120
255
 
121
 
    Returned value can be unicode or plain sring.
122
 
    To convert plain string to unicode use
123
 
    s.decode(bzrlib.user_encoding)
 
256
    Windows defines two 'Application Data' folders per user - a 'roaming'
 
257
    one that moves with the user as they logon to different machines, and
 
258
    a 'local' one that stays local to the machine.  This returns the 'roaming'
 
259
    directory, and thus is suitable for storing user-preferences, etc.
124
260
    """
125
 
    if has_ctypes:
126
 
        try:
127
 
            SHGetSpecialFolderPath = \
128
 
                ctypes.windll.shell32.SHGetSpecialFolderPathW
129
 
        except AttributeError:
130
 
            pass
131
 
        else:
132
 
            buf = ctypes.create_unicode_buffer(MAX_PATH)
133
 
            if SHGetSpecialFolderPath(None,buf,CSIDL_APPDATA,0):
134
 
                return buf.value
135
 
    # from env variable
136
 
    appdata = os.environ.get('APPDATA')
 
261
    appdata = _get_sh_special_folder_path(CSIDL_APPDATA)
137
262
    if appdata:
138
263
        return appdata
139
 
    # if we fall to this point we on win98
140
 
    # at least try C:/WINDOWS/Application Data
141
 
    windir = os.environ.get('windir')
142
 
    if windir:
143
 
        appdata = os.path.join(windir, 'Application Data')
144
 
        if os.path.isdir(appdata):
145
 
            return appdata
146
 
    # did not find anything
147
 
    return None
 
264
    # Use APPDATA if defined, will return None if not
 
265
    return get_environ_unicode('APPDATA')
 
266
 
 
267
 
 
268
def get_local_appdata_location():
 
269
    """Return Local Application Data location.
 
270
    Return the same as get_appdata_location() if we cannot obtain location.
 
271
 
 
272
    Windows defines two 'Application Data' folders per user - a 'roaming'
 
273
    one that moves with the user as they logon to different machines, and
 
274
    a 'local' one that stays local to the machine.  This returns the 'local'
 
275
    directory, and thus is suitable for caches, temp files and other things
 
276
    which don't need to move with the user.
 
277
    """
 
278
    local = _get_sh_special_folder_path(CSIDL_LOCAL_APPDATA)
 
279
    if local:
 
280
        return local
 
281
    # Vista supplies LOCALAPPDATA, but XP and earlier do not.
 
282
    local = get_environ_unicode('LOCALAPPDATA')
 
283
    if local:
 
284
        return local
 
285
    return get_appdata_location()
148
286
 
149
287
 
150
288
def get_home_location():
152
290
    Assume on win32 it's the <My Documents> folder.
153
291
    If location cannot be obtained return system drive root,
154
292
    i.e. C:\
155
 
 
156
 
    Returned value can be unicode or plain sring.
157
 
    To convert plain string to unicode use
158
 
    s.decode(bzrlib.user_encoding)
159
293
    """
160
 
    if has_ctypes:
161
 
        try:
162
 
            SHGetSpecialFolderPath = \
163
 
                ctypes.windll.shell32.SHGetSpecialFolderPathW
164
 
        except AttributeError:
165
 
            pass
166
 
        else:
167
 
            buf = ctypes.create_unicode_buffer(MAX_PATH)
168
 
            if SHGetSpecialFolderPath(None,buf,CSIDL_PERSONAL,0):
169
 
                return buf.value
170
 
    # try for HOME env variable
171
 
    home = os.path.expanduser('~')
172
 
    if home != '~':
173
 
        return home
 
294
    home = _get_sh_special_folder_path(CSIDL_PERSONAL)
 
295
    if home:
 
296
        return home
 
297
    home = get_environ_unicode('HOME')
 
298
    if home is not None:
 
299
        return home
 
300
    homepath = get_environ_unicode('HOMEPATH')
 
301
    if homepath is not None:
 
302
        return os.path.join(get_environ_unicode('HOMEDIR', ''), home)
174
303
    # at least return windows root directory
175
 
    windir = os.environ.get('windir')
 
304
    windir = get_environ_unicode('WINDIR')
176
305
    if windir:
177
306
        return os.path.splitdrive(windir)[0] + '/'
178
307
    # otherwise C:\ is good enough for 98% users
179
 
    return 'C:/'
 
308
    return unicode('C:/')
180
309
 
181
310
 
182
311
def get_user_name():
183
312
    """Return user name as login name.
184
313
    If name cannot be obtained return None.
185
 
 
186
 
    Returned value can be unicode or plain sring.
187
 
    To convert plain string to unicode use
188
 
    s.decode(bzrlib.user_encoding)
189
314
    """
190
315
    if has_ctypes:
191
316
        try:
197
322
            buf = create_buffer(UNLEN+1)
198
323
            n = ctypes.c_int(UNLEN+1)
199
324
            if GetUserName(buf, ctypes.byref(n)):
200
 
                return buf.value
 
325
                return extract_buffer(buf)
201
326
    # otherwise try env variables
202
 
    return os.environ.get('USERNAME', None)
203
 
 
 
327
    return get_environ_unicode('USERNAME')
 
328
 
 
329
 
 
330
# 1 == ComputerNameDnsHostname, which returns "The DNS host name of the local
 
331
# computer or the cluster associated with the local computer."
 
332
_WIN32_ComputerNameDnsHostname = 1
204
333
 
205
334
def get_host_name():
206
335
    """Return host machine name.
207
336
    If name cannot be obtained return None.
208
337
 
209
 
    Returned value can be unicode or plain sring.
210
 
    To convert plain string to unicode use
211
 
    s.decode(bzrlib.user_encoding)
 
338
    :return: A unicode string representing the host name.
212
339
    """
 
340
    if has_win32api:
 
341
        try:
 
342
            return win32api.GetComputerNameEx(_WIN32_ComputerNameDnsHostname)
 
343
        except (NotImplementedError, win32api.error):
 
344
            # NotImplemented will happen on win9x...
 
345
            pass
213
346
    if has_ctypes:
214
347
        try:
215
348
            kernel32 = ctypes.windll.kernel32
216
 
            GetComputerName = getattr(kernel32, 'GetComputerName'+suffix)
217
349
        except AttributeError:
218
 
            pass
 
350
            pass # Missing the module we need
219
351
        else:
220
352
            buf = create_buffer(MAX_COMPUTERNAME_LENGTH+1)
221
353
            n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
222
 
            if GetComputerName(buf, ctypes.byref(n)):
223
 
                return buf.value
224
 
    # otherwise try env variables
225
 
    return os.environ.get('COMPUTERNAME', None)
226
 
 
227
 
 
 
354
 
 
355
            # Try GetComputerNameEx which gives a proper Unicode hostname
 
356
            GetComputerNameEx = getattr(kernel32, 'GetComputerNameEx'+suffix,
 
357
                                        None)
 
358
            if (GetComputerNameEx is not None
 
359
                and GetComputerNameEx(_WIN32_ComputerNameDnsHostname,
 
360
                                      buf, ctypes.byref(n))):
 
361
                return extract_buffer(buf)
 
362
 
 
363
            # Try GetComputerName in case GetComputerNameEx wasn't found
 
364
            # It returns the NETBIOS name, which isn't as good, but still ok.
 
365
            # The first GetComputerNameEx might have changed 'n', so reset it
 
366
            n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
 
367
            GetComputerName = getattr(kernel32, 'GetComputerName'+suffix,
 
368
                                      None)
 
369
            if (GetComputerName is not None
 
370
                and GetComputerName(buf, ctypes.byref(n))):
 
371
                return extract_buffer(buf)
 
372
    return get_environ_unicode('COMPUTERNAME')
 
373
 
 
374
 
 
375
@symbol_versioning.deprecated_function(
 
376
    symbol_versioning.deprecated_in((2, 5, 0)))
228
377
def _ensure_unicode(s):
229
378
    if s and type(s) != unicode:
230
 
        import bzrlib
231
 
        s = s.decode(bzrlib.user_encoding)
 
379
        from bzrlib import osutils
 
380
        s = s.decode(osutils.get_user_encoding())
232
381
    return s
233
 
    
234
 
 
235
 
def get_appdata_location_unicode():
236
 
    return _ensure_unicode(get_appdata_location())
237
 
 
238
 
def get_home_location_unicode():
239
 
    return _ensure_unicode(get_home_location())
240
 
 
241
 
def get_user_name_unicode():
242
 
    return _ensure_unicode(get_user_name())
243
 
 
244
 
def get_host_name_unicode():
245
 
    return _ensure_unicode(get_host_name())
 
382
 
 
383
 
 
384
get_appdata_location_unicode = symbol_versioning.deprecated_function(
 
385
    symbol_versioning.deprecated_in((2, 5, 0)))(get_appdata_location)
 
386
 
 
387
get_home_location_unicode = symbol_versioning.deprecated_function(
 
388
    symbol_versioning.deprecated_in((2, 5, 0)))(get_home_location)
 
389
 
 
390
get_user_name_unicode = symbol_versioning.deprecated_function(
 
391
    symbol_versioning.deprecated_in((2, 5, 0)))(get_user_name)
 
392
 
 
393
get_host_name_unicode = symbol_versioning.deprecated_function(
 
394
    symbol_versioning.deprecated_in((2, 5, 0)))(get_host_name)
246
395
 
247
396
 
248
397
def _ensure_with_dir(path):
249
 
    if not os.path.split(path)[0] or path.startswith(u'*') or path.startswith(u'?'):
 
398
    if (not os.path.split(path)[0] or path.startswith(u'*')
 
399
        or path.startswith(u'?')):
250
400
        return u'./' + path, True
251
401
    else:
252
402
        return path, False
253
 
    
 
403
 
254
404
def _undo_ensure_with_dir(path, corrected):
255
405
    if corrected:
256
406
        return path[2:]
258
408
        return path
259
409
 
260
410
 
 
411
def glob_one(possible_glob):
 
412
    """Same as glob.glob().
 
413
 
 
414
    work around bugs in glob.glob()
 
415
    - Python bug #1001604 ("glob doesn't return unicode with ...")
 
416
    - failing expansion for */* with non-iso-8859-* chars
 
417
    """
 
418
    corrected_glob, corrected = _ensure_with_dir(possible_glob)
 
419
    glob_files = glob.glob(corrected_glob)
 
420
 
 
421
    if not glob_files:
 
422
        # special case to let the normal code path handle
 
423
        # files that do not exist, etc.
 
424
        glob_files = [possible_glob]
 
425
    elif corrected:
 
426
        glob_files = [_undo_ensure_with_dir(elem, corrected)
 
427
                      for elem in glob_files]
 
428
    return [elem.replace(u'\\', u'/') for elem in glob_files]
 
429
 
261
430
 
262
431
def glob_expand(file_list):
263
432
    """Replacement for glob expansion by the shell.
272
441
    """
273
442
    if not file_list:
274
443
        return []
275
 
    import glob
276
444
    expanded_file_list = []
277
445
    for possible_glob in file_list:
278
 
        
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)
284
 
 
285
 
        if glob_files == []:
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))
290
 
        else:
291
 
            glob_files = [_undo_ensure_with_dir(elem, corrected) for elem in glob_files]
292
 
            expanded_file_list += glob_files
293
 
            
294
 
    return [elem.replace(u'\\', u'/') for elem in expanded_file_list] 
 
446
        expanded_file_list.extend(glob_one(possible_glob))
 
447
    return expanded_file_list
295
448
 
296
449
 
297
450
def get_app_path(appname):
298
 
    """Look up in Windows registry for full path to application executable.
299
 
    Typicaly, applications create subkey with their basename
 
451
    r"""Look up in Windows registry for full path to application executable.
 
452
    Typically, applications create subkey with their basename
300
453
    in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\
301
454
 
302
455
    :param  appname:    name of application (if no filename extension
305
458
                or appname itself if nothing found.
306
459
    """
307
460
    import _winreg
 
461
 
 
462
    basename = appname
 
463
    if not os.path.splitext(basename)[1]:
 
464
        basename = appname + '.exe'
 
465
 
308
466
    try:
309
467
        hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
310
 
                               r'SOFTWARE\Microsoft\Windows'
311
 
                               r'\CurrentVersion\App Paths')
 
468
            'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +
 
469
            basename)
312
470
    except EnvironmentError:
313
471
        return appname
314
472
 
315
 
    basename = appname
316
 
    if not os.path.splitext(basename)[1]:
317
 
        basename = appname + '.exe'
318
473
    try:
319
474
        try:
320
 
            fullpath = _winreg.QueryValue(hkey, basename)
 
475
            path, type_id = _winreg.QueryValueEx(hkey, '')
321
476
        except WindowsError:
322
 
            fullpath = appname
 
477
            return appname
323
478
    finally:
324
479
        _winreg.CloseKey(hkey)
325
480
 
326
 
    return fullpath
 
481
    if type_id == REG_SZ:
 
482
        return path
 
483
    if type_id == REG_EXPAND_SZ and has_win32api:
 
484
        fullpath = win32api.ExpandEnvironmentStrings(path)
 
485
        if len(fullpath) > 1 and fullpath[0] == '"' and fullpath[-1] == '"':
 
486
            fullpath = fullpath[1:-1]   # remove quotes around value
 
487
        return fullpath
 
488
    return appname
327
489
 
328
490
 
329
491
def set_file_attr_hidden(path):
330
492
    """Set file attributes to hidden if possible"""
331
493
    if has_win32file:
332
 
        win32file.SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)
 
494
        if winver != 'Windows 98':
 
495
            SetFileAttributes = win32file.SetFileAttributesW
 
496
        else:
 
497
            SetFileAttributes = win32file.SetFileAttributes
 
498
        try:
 
499
            SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)
 
500
        except pywintypes.error, e:
 
501
            from bzrlib import trace
 
502
            trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
 
503
 
 
504
 
 
505
def _command_line_to_argv(command_line, argv, single_quotes_allowed=False):
 
506
    """Convert a Unicode command line into a list of argv arguments.
 
507
 
 
508
    It performs wildcard expansion to make wildcards act closer to how they
 
509
    work in posix shells, versus how they work by default on Windows. Quoted
 
510
    arguments are left untouched.
 
511
 
 
512
    :param command_line: The unicode string to split into an arg list.
 
513
    :param single_quotes_allowed: Whether single quotes are accepted as quoting
 
514
                                  characters like double quotes. False by
 
515
                                  default.
 
516
    :return: A list of unicode strings.
 
517
    """
 
518
    # First, split the command line
 
519
    s = cmdline.Splitter(command_line, single_quotes_allowed=single_quotes_allowed)
 
520
    
 
521
    # Bug #587868 Now make sure that the length of s agrees with sys.argv 
 
522
    # we do this by simply counting the number of arguments in each. The counts should 
 
523
    # agree no matter what encoding sys.argv is in (AFAIK) 
 
524
    # len(arguments) < len(sys.argv) should be an impossibility since python gets 
 
525
    # args from the very same PEB as does GetCommandLineW
 
526
    arguments = list(s)
 
527
    
 
528
    # Now shorten the command line we get from GetCommandLineW to match sys.argv
 
529
    if len(arguments) < len(argv):
 
530
        raise AssertionError("Split command line can't be shorter than argv")
 
531
    arguments = arguments[len(arguments) - len(argv):]
 
532
    
 
533
    # Carry on to process globs (metachars) in the command line
 
534
    # expand globs if necessary
 
535
    # TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
 
536
    #       '**/' style globs
 
537
    args = []
 
538
    for is_quoted, arg in arguments:
 
539
        if is_quoted or not glob.has_magic(arg):
 
540
            args.append(arg)
 
541
        else:
 
542
            args.extend(glob_one(arg))
 
543
    return args
 
544
 
 
545
 
 
546
if has_ctypes and winver == 'Windows NT':
 
547
    def get_unicode_argv():
 
548
        prototype = ctypes.WINFUNCTYPE(ctypes.c_wchar_p)
 
549
        GetCommandLineW = prototype(("GetCommandLineW",
 
550
                                     ctypes.windll.kernel32))
 
551
        command_line = GetCommandLineW()
 
552
        if command_line is None:
 
553
            raise ctypes.WinError()
 
554
        # Skip the first argument, since we only care about parameters
 
555
        argv = _command_line_to_argv(command_line, sys.argv)[1:]
 
556
        return argv
 
557
    
 
558
 
 
559
    def get_environ_unicode(key, default=None):
 
560
        """Get `key` from environment as unicode or `default` if unset
 
561
 
 
562
        The environment is natively unicode on modern windows versions but
 
563
        Python 2 only accesses it through the legacy bytestring api.
 
564
 
 
565
        Environmental variable names are case insenstive on Windows.
 
566
 
 
567
        A large enough buffer will be allocated to retrieve the value, though
 
568
        it may take two calls to the underlying library function.
 
569
 
 
570
        This needs ctypes because pywin32 does not expose the wide version.
 
571
        """
 
572
        cfunc = getattr(get_environ_unicode, "_c_function", None)
 
573
        if cfunc is None:
 
574
            from ctypes.wintypes import DWORD, LPCWSTR, LPWSTR
 
575
            cfunc = ctypes.WINFUNCTYPE(DWORD, LPCWSTR, LPWSTR, DWORD)(
 
576
                ("GetEnvironmentVariableW", ctypes.windll.kernel32))
 
577
            get_environ_unicode._c_function = cfunc
 
578
        buffer_size = 256 # heuristic, 256 characters often enough
 
579
        while True:
 
580
            buffer = ctypes.create_unicode_buffer(buffer_size)
 
581
            length = cfunc(key, buffer, buffer_size)
 
582
            if not length:
 
583
                code = ctypes.GetLastError()
 
584
                if code == 203: # ERROR_ENVVAR_NOT_FOUND
 
585
                    return default
 
586
                raise ctypes.WinError(code)
 
587
            if buffer_size > length:
 
588
                return buffer[:length]
 
589
            buffer_size = length
 
590
else:
 
591
    get_unicode_argv = None
 
592
    def get_environ_unicode(key, default=None):
 
593
        """Get `key` from environment as unicode or `default` if unset
 
594
 
 
595
        Fallback version that should basically never be needed.
 
596
        """
 
597
        from bzrlib import osutils
 
598
        try:
 
599
            return os.environ[key].decode(osutils.get_user_encoding())
 
600
        except KeyError:
 
601
            return default
 
602
 
 
603
 
 
604
if has_win32api:
 
605
    def _pywin32_is_local_pid_dead(pid):
 
606
        """True if pid doesn't correspond to live process on this machine"""
 
607
        try:
 
608
            handle = win32api.OpenProcess(1, False, pid) # PROCESS_TERMINATE
 
609
        except pywintypes.error, e:
 
610
            if e[0] == 5: # ERROR_ACCESS_DENIED
 
611
                # Probably something alive we're not allowed to kill
 
612
                return False
 
613
            elif e[0] == 87: # ERROR_INVALID_PARAMETER
 
614
                return True
 
615
            raise
 
616
        handle.close()
 
617
        return False
 
618
    is_local_pid_dead = _pywin32_is_local_pid_dead
 
619
elif has_ctypes and sys.platform == 'win32':
 
620
    from ctypes.wintypes import BOOL, DWORD, HANDLE
 
621
    _kernel32 = ctypes.windll.kernel32
 
622
    _CloseHandle = ctypes.WINFUNCTYPE(BOOL, HANDLE)(
 
623
        ("CloseHandle", _kernel32))
 
624
    _OpenProcess = ctypes.WINFUNCTYPE(HANDLE, DWORD, BOOL, DWORD)(
 
625
        ("OpenProcess", _kernel32))
 
626
    def _ctypes_is_local_pid_dead(pid):
 
627
        """True if pid doesn't correspond to live process on this machine"""
 
628
        handle = _OpenProcess(1, False, pid) # PROCESS_TERMINATE
 
629
        if not handle:
 
630
            errorcode = ctypes.GetLastError()
 
631
            if errorcode == 5: # ERROR_ACCESS_DENIED
 
632
                # Probably something alive we're not allowed to kill
 
633
                return False
 
634
            elif errorcode == 87: # ERROR_INVALID_PARAMETER
 
635
                return True
 
636
            raise ctypes.WinError(errorcode)
 
637
        _CloseHandle(handle)
 
638
        return False
 
639
    is_local_pid_dead = _ctypes_is_local_pid_dead
 
640
 
 
641
 
 
642
def _is_pywintypes_error(evalue):
 
643
    """True if exception instance is an error from pywin32"""
 
644
    if has_pywintypes and isinstance(evalue, pywintypes.error):
 
645
        return True
 
646
    return False