/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: Richard Wilbur
  • Date: 2016-02-04 19:07:28 UTC
  • mto: This revision was merged to the branch mainline in revision 6618.
  • Revision ID: richard.wilbur@gmail.com-20160204190728-p0zvfii6zase0fw7
Update COPYING.txt from the original http://www.gnu.org/licenses/gpl-2.0.txt  (Only differences were in whitespace.)  Thanks to Petr Stodulka for pointing out the discrepancy.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/win32utils.py
19
19
Only one dependency: ctypes should be installed.
20
20
"""
21
21
 
 
22
from __future__ import absolute_import
 
23
 
22
24
import glob
 
25
import operator
23
26
import os
24
27
import struct
25
28
import sys
26
29
 
27
 
from breezy import (
 
30
from bzrlib import (
28
31
    cmdline,
 
32
    symbol_versioning,
29
33
    )
30
 
from breezy.i18n import gettext
31
 
 
 
34
from bzrlib.i18n import gettext
 
35
 
 
36
# Windows version
 
37
if sys.platform == 'win32':
 
38
    _major,_minor,_build,_platform,_text = sys.getwindowsversion()
 
39
    # from MSDN:
 
40
    # dwPlatformId
 
41
    #   The operating system platform.
 
42
    #   This member can be one of the following values.
 
43
    #   ==========================  ======================================
 
44
    #   Value                       Meaning
 
45
    #   --------------------------  --------------------------------------
 
46
    #   VER_PLATFORM_WIN32_NT       The operating system is Windows Vista,
 
47
    #   2                           Windows Server "Longhorn",
 
48
    #                               Windows Server 2003, Windows XP,
 
49
    #                               Windows 2000, or Windows NT.
 
50
    #
 
51
    #   VER_PLATFORM_WIN32_WINDOWS  The operating system is Windows Me,
 
52
    #   1                           Windows 98, or Windows 95.
 
53
    #   ==========================  ======================================
 
54
    if _platform == 2:
 
55
        winver = 'Windows NT'
 
56
    else:
 
57
        # don't care about real Windows name, just to force safe operations
 
58
        winver = 'Windows 98'
 
59
else:
 
60
    winver = None
 
61
 
 
62
 
 
63
# We can cope without it; use a separate variable to help pyflakes
 
64
try:
 
65
    import ctypes
 
66
    has_ctypes = True
 
67
except ImportError:
 
68
    has_ctypes = False
 
69
else:
 
70
    if winver == 'Windows 98':
 
71
        create_buffer = ctypes.create_string_buffer
 
72
        def extract_buffer(buf):
 
73
            return buf.value.decode("mbcs")
 
74
        suffix = 'A'
 
75
    else:
 
76
        create_buffer = ctypes.create_unicode_buffer
 
77
        extract_buffer = operator.attrgetter("value")
 
78
        suffix = 'W'
 
79
try:
 
80
    import pywintypes
 
81
    has_pywintypes = True
 
82
except ImportError:
 
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
 
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...
32
100
 
33
101
# Special Win32 API constants
34
102
# Handles of std streams
38
106
 
39
107
# CSIDL constants (from MSDN 2003)
40
108
CSIDL_APPDATA = 0x001A      # Application Data folder
41
 
# <user name>\Local Settings\Application Data (non roaming)
42
 
CSIDL_LOCAL_APPDATA = 0x001c
 
109
CSIDL_LOCAL_APPDATA = 0x001c# <user name>\Local Settings\Application Data (non roaming)
43
110
CSIDL_PERSONAL = 0x0005     # My Documents folder
44
111
 
45
112
# from winapi C headers
54
121
 
55
122
def debug_memory_win32api(message='', short=True):
56
123
    """Use trace.note() to dump the running memory info."""
57
 
    import ctypes
58
 
    from breezy import trace
59
 
    class PROCESS_MEMORY_COUNTERS_EX(ctypes.Structure):
60
 
        """Used by GetProcessMemoryInfo"""
61
 
        _fields_ = [('cb', ctypes.c_ulong),
62
 
                    ('PageFaultCount', ctypes.c_ulong),
63
 
                    ('PeakWorkingSetSize', ctypes.c_size_t),
64
 
                    ('WorkingSetSize', ctypes.c_size_t),
65
 
                    ('QuotaPeakPagedPoolUsage', ctypes.c_size_t),
66
 
                    ('QuotaPagedPoolUsage', ctypes.c_size_t),
67
 
                    ('QuotaPeakNonPagedPoolUsage', ctypes.c_size_t),
68
 
                    ('QuotaNonPagedPoolUsage', ctypes.c_size_t),
69
 
                    ('PagefileUsage', ctypes.c_size_t),
70
 
                    ('PeakPagefileUsage', ctypes.c_size_t),
71
 
                    ('PrivateUsage', ctypes.c_size_t),
72
 
                    ]
73
 
    cur_process = ctypes.windll.kernel32.GetCurrentProcess()
74
 
    mem_struct = PROCESS_MEMORY_COUNTERS_EX()
75
 
    ret = ctypes.windll.psapi.GetProcessMemoryInfo(
76
 
        cur_process, ctypes.byref(mem_struct), ctypes.sizeof(mem_struct))
77
 
    if not ret:
78
 
        trace.note(gettext('Failed to GetProcessMemoryInfo()'))
 
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'))
79
169
        return
80
 
    info = {'PageFaultCount': mem_struct.PageFaultCount,
81
 
            'PeakWorkingSetSize': mem_struct.PeakWorkingSetSize,
82
 
            'WorkingSetSize': mem_struct.WorkingSetSize,
83
 
            'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,
84
 
            'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,
85
 
            'QuotaPeakNonPagedPoolUsage':
86
 
                mem_struct.QuotaPeakNonPagedPoolUsage,
87
 
            'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,
88
 
            'PagefileUsage': mem_struct.PagefileUsage,
89
 
            'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
90
 
            'PrivateUsage': mem_struct.PrivateUsage,
91
 
            }
92
170
    if short:
93
171
        # using base-2 units (see HACKING.txt).
94
172
        trace.note(gettext('WorkingSize {0:>7}KiB'
95
 
                           '\tPeakWorking {1:>7}KiB\t{2}').format(
 
173
                   '\tPeakWorking {1:>7}KiB\t{2}').format(
96
174
                   info['WorkingSetSize'] / 1024,
97
175
                   info['PeakWorkingSetSize'] / 1024,
98
176
                   message))
99
177
        return
100
178
    if message:
101
179
        trace.note('%s', message)
102
 
    trace.note(gettext('WorkingSize       %8d KiB'),
103
 
               info['WorkingSetSize'] / 1024)
104
 
    trace.note(gettext('PeakWorking       %8d KiB'),
105
 
               info['PeakWorkingSetSize'] / 1024)
106
 
    trace.note(gettext('PagefileUsage     %8d KiB'),
107
 
               info.get('PagefileUsage', 0) / 1024)
 
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)
108
183
    trace.note(gettext('PeakPagefileUsage %8d KiB'),
109
184
               info.get('PeakPagefileUsage', 0) / 1024)
110
 
    trace.note(gettext('PrivateUsage      %8d KiB'),
111
 
               info.get('PrivateUsage', 0) / 1024)
 
185
    trace.note(gettext('PrivateUsage      %8d KiB'), info.get('PrivateUsage', 0) / 1024)
112
186
    trace.note(gettext('PageFaultCount    %8d'), info.get('PageFaultCount', 0))
113
187
 
114
188
 
119
193
    console window and return tuple (sizex, sizey) if success,
120
194
    or default size (defaultx, defaulty) otherwise.
121
195
    """
122
 
    import ctypes
 
196
    if not has_ctypes:
 
197
        # no ctypes is found
 
198
        return (defaultx, defaulty)
 
199
 
123
200
    # To avoid problem with redirecting output via pipe
124
201
    # we need to use stderr instead of stdout
125
202
    h = ctypes.windll.kernel32.GetStdHandle(WIN32_STDERR_HANDLE)
128
205
 
129
206
    if res:
130
207
        (bufx, bufy, curx, cury, wattr,
131
 
         left, top, right, bottom, maxx, maxy) = struct.unpack(
 
208
        left, top, right, bottom, maxx, maxy) = struct.unpack(
132
209
            "hhhhHhhhhhh", csbi.raw)
133
210
        sizex = right - left + 1
134
211
        sizey = bottom - top + 1
142
219
 
143
220
    Result is always unicode (or None).
144
221
    """
145
 
    import ctypes
146
 
    try:
147
 
        SHGetSpecialFolderPath = \
148
 
            ctypes.windll.shell32.SHGetSpecialFolderPathW
149
 
    except AttributeError:
150
 
        pass
151
 
    else:
152
 
        buf = ctypes.create_unicode_buffer(MAX_PATH)
153
 
        if SHGetSpecialFolderPath(None, buf, csidl, 0):
154
 
            return buf.value
 
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
155
250
 
156
251
 
157
252
def get_appdata_location():
167
262
    if appdata:
168
263
        return appdata
169
264
    # Use APPDATA if defined, will return None if not
170
 
    return os.environ.get('APPDATA')
 
265
    return get_environ_unicode('APPDATA')
171
266
 
172
267
 
173
268
def get_local_appdata_location():
184
279
    if local:
185
280
        return local
186
281
    # Vista supplies LOCALAPPDATA, but XP and earlier do not.
187
 
    local = os.environ.get('LOCALAPPDATA')
 
282
    local = get_environ_unicode('LOCALAPPDATA')
188
283
    if local:
189
284
        return local
190
285
    return get_appdata_location()
199
294
    home = _get_sh_special_folder_path(CSIDL_PERSONAL)
200
295
    if home:
201
296
        return home
202
 
    home = os.environ.get('HOME')
 
297
    home = get_environ_unicode('HOME')
203
298
    if home is not None:
204
299
        return home
205
 
    homepath = os.environ.get('HOMEPATH')
 
300
    homepath = get_environ_unicode('HOMEPATH')
206
301
    if homepath is not None:
207
 
        return os.path.join(os.environ.get('HOMEDIR', ''), home)
 
302
        return os.path.join(get_environ_unicode('HOMEDIR', ''), home)
208
303
    # at least return windows root directory
209
 
    windir = os.environ.get('WINDIR')
 
304
    windir = get_environ_unicode('WINDIR')
210
305
    if windir:
211
306
        return os.path.splitdrive(windir)[0] + '/'
212
307
    # otherwise C:\ is good enough for 98% users
213
 
    return u'C:/'
 
308
    return unicode('C:/')
214
309
 
215
310
 
216
311
def get_user_name():
217
312
    """Return user name as login name.
218
313
    If name cannot be obtained return None.
219
314
    """
220
 
    try:
221
 
        advapi32 = ctypes.windll.advapi32
222
 
        GetUserName = getattr(advapi32, 'GetUserNameW')
223
 
    except AttributeError:
224
 
        pass
225
 
    else:
226
 
        buf = ctypes.create_unicode_buffer(UNLEN + 1)
227
 
        n = ctypes.c_int(UNLEN + 1)
228
 
        if GetUserName(buf, ctypes.byref(n)):
229
 
            return buf.value
 
315
    if has_ctypes:
 
316
        try:
 
317
            advapi32 = ctypes.windll.advapi32
 
318
            GetUserName = getattr(advapi32, 'GetUserName'+suffix)
 
319
        except AttributeError:
 
320
            pass
 
321
        else:
 
322
            buf = create_buffer(UNLEN+1)
 
323
            n = ctypes.c_int(UNLEN+1)
 
324
            if GetUserName(buf, ctypes.byref(n)):
 
325
                return extract_buffer(buf)
230
326
    # otherwise try env variables
231
 
    return os.environ.get('USERNAME')
 
327
    return get_environ_unicode('USERNAME')
232
328
 
233
329
 
234
330
# 1 == ComputerNameDnsHostname, which returns "The DNS host name of the local
235
331
# computer or the cluster associated with the local computer."
236
332
_WIN32_ComputerNameDnsHostname = 1
237
333
 
238
 
 
239
334
def get_host_name():
240
335
    """Return host machine name.
241
336
    If name cannot be obtained return None.
242
337
 
243
338
    :return: A unicode string representing the host name.
244
339
    """
245
 
    import ctypes
246
 
    buf = ctypes.create_unicode_buffer(MAX_COMPUTERNAME_LENGTH + 1)
247
 
    n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH + 1)
248
 
 
249
 
    # Try GetComputerNameEx which gives a proper Unicode hostname
250
 
    GetComputerNameEx = getattr(
251
 
        ctypes.windll.kernel32, 'GetComputerNameExW', None)
252
 
    if (GetComputerNameEx is not None
253
 
        and GetComputerNameEx(_WIN32_ComputerNameDnsHostname,
254
 
                              buf, ctypes.byref(n))):
255
 
        return buf.value
256
 
    return os.environ.get('COMPUTERNAME')
 
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
 
346
    if has_ctypes:
 
347
        try:
 
348
            kernel32 = ctypes.windll.kernel32
 
349
        except AttributeError:
 
350
            pass # Missing the module we need
 
351
        else:
 
352
            buf = create_buffer(MAX_COMPUTERNAME_LENGTH+1)
 
353
            n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
 
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)))
 
377
def _ensure_unicode(s):
 
378
    if s and type(s) != unicode:
 
379
        from bzrlib import osutils
 
380
        s = s.decode(osutils.get_user_encoding())
 
381
    return s
 
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)
257
395
 
258
396
 
259
397
def _ensure_with_dir(path):
260
398
    if (not os.path.split(path)[0] or path.startswith(u'*')
261
 
            or path.startswith(u'?')):
 
399
        or path.startswith(u'?')):
262
400
        return u'./' + path, True
263
401
    else:
264
402
        return path, False
265
403
 
266
 
 
267
404
def _undo_ensure_with_dir(path, corrected):
268
405
    if corrected:
269
406
        return path[2:]
300
437
    :param file_list: A list of filenames which may include shell globs.
301
438
    :return: An expanded list of filenames.
302
439
 
303
 
    Introduced in breezy 0.18.
 
440
    Introduced in bzrlib 0.18.
304
441
    """
305
442
    if not file_list:
306
443
        return []
328
465
 
329
466
    try:
330
467
        hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
331
 
                               'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +
332
 
                               basename)
 
468
            'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +
 
469
            basename)
333
470
    except EnvironmentError:
334
471
        return appname
335
472
 
343
480
 
344
481
    if type_id == REG_SZ:
345
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
346
488
    return appname
347
489
 
348
490
 
349
491
def set_file_attr_hidden(path):
350
492
    """Set file attributes to hidden if possible"""
351
 
    from ctypes.wintypes import BOOL, DWORD, LPWSTR
352
 
    import ctypes
353
 
    # <https://docs.microsoft.com/windows/desktop/api/fileapi/nf-fileapi-setfileattributesw>
354
 
    SetFileAttributes = ctypes.windll.kernel32.SetFileAttributesW
355
 
    SetFileAttributes.argtypes = LPWSTR, DWORD
356
 
    SetFileAttributes.restype = BOOL
357
 
    FILE_ATTRIBUTE_HIDDEN = 2
358
 
    if not SetFileAttributes(path, FILE_ATTRIBUTE_HIDDEN):
359
 
        e = ctypes.WinError()
360
 
        from . import trace
361
 
        trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
 
493
    if has_win32file:
 
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)
362
503
 
363
504
 
364
505
def _command_line_to_argv(command_line, argv, single_quotes_allowed=False):
375
516
    :return: A list of unicode strings.
376
517
    """
377
518
    # First, split the command line
378
 
    s = cmdline.Splitter(
379
 
        command_line, single_quotes_allowed=single_quotes_allowed)
380
 
 
381
 
    # Bug #587868 Now make sure that the length of s agrees with sys.argv
382
 
    # we do this by simply counting the number of arguments in each. The counts should
383
 
    # agree no matter what encoding sys.argv is in (AFAIK)
384
 
    # len(arguments) < len(sys.argv) should be an impossibility since python gets
 
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 
385
525
    # args from the very same PEB as does GetCommandLineW
386
526
    arguments = list(s)
387
 
 
 
527
    
388
528
    # Now shorten the command line we get from GetCommandLineW to match sys.argv
389
529
    if len(arguments) < len(argv):
390
530
        raise AssertionError("Split command line can't be shorter than argv")
391
531
    arguments = arguments[len(arguments) - len(argv):]
392
 
 
 
532
    
393
533
    # Carry on to process globs (metachars) in the command line
394
534
    # expand globs if necessary
395
535
    # TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
403
543
    return args
404
544
 
405
545
 
406
 
def _ctypes_is_local_pid_dead(pid):
407
 
    import ctypes
408
 
    kernel32 = ctypes.wintypes.windll.kernel32
409
 
    """True if pid doesn't correspond to live process on this machine"""
410
 
    handle = kernel32.OpenProcess(1, False, pid)
411
 
    if not handle:
412
 
        errorcode = ctypes.GetLastError()
413
 
        if errorcode == 5:  # ERROR_ACCESS_DENIED
414
 
            # Probably something alive we're not allowed to kill
415
 
            return False
416
 
        elif errorcode == 87:  # ERROR_INVALID_PARAMETER
417
 
            return True
418
 
        raise ctypes.WinError(errorcode)
419
 
    Kernel32.CloseHandle(handle)
 
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
420
646
    return False
421
 
 
422
 
is_local_pid_dead = _ctypes_is_local_pid_dead