/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/win32utils.py

  • Committer: Colin D Bennett
  • Date: 2009-02-12 16:57:39 UTC
  • mto: This revision was merged to the branch mainline in revision 4008.
  • Revision ID: colin@gibibit.com-20090212165739-02xv63odccfmxomw
Generate PDF version of the User Guide.

Show diffs side-by-side

added added

removed removed

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